KiritoTRw
GitHub
parent
1b4d6396e4
commit
27767e72ab
|
|
@ -0,0 +1,10 @@
|
|||
#include<iostream>
|
||||
using namespace std;
|
||||
int main()
|
||||
{
|
||||
int n;
|
||||
while(scanf("%d",&n)!=EOF&&n)
|
||||
{
|
||||
printf("%d\n",(n+1)>>1);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,17 @@
|
|||
#include<iostream>
|
||||
using namespace std;
|
||||
int main()
|
||||
{
|
||||
long T,yu;
|
||||
long feng;
|
||||
while(cin>>T&&T)
|
||||
{
|
||||
yu=T%4018;
|
||||
if(yu%2==0)
|
||||
feng=((((yu*yu)/4)%2009)*((2*yu+3)%2009));
|
||||
else
|
||||
feng=((((yu+1)*(yu+1)/4)%2009)*((2*yu-1)%2009));
|
||||
printf("%ld\n",feng%2009);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,25 @@
|
|||
#include <stdio.h>
|
||||
int main ()
|
||||
{
|
||||
__int64 n,m,a[102],i,max,t;
|
||||
while(scanf("%I64d",&n)!=EOF&&n!=0)
|
||||
{
|
||||
max=0;t=0;
|
||||
for(i=0;i<n;i++)
|
||||
{
|
||||
scanf("%I64d",&a[i]);
|
||||
if(a[i]>max)
|
||||
{
|
||||
max=a[i];
|
||||
t=i;
|
||||
}
|
||||
}
|
||||
m=0;
|
||||
for(i=0;i<n;i++)
|
||||
{
|
||||
m=m+a[i];
|
||||
}
|
||||
m=m-a[t]+a[t]*(2010-n);
|
||||
printf("%I64d\n",m);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,17 @@
|
|||
#include <cstdio>
|
||||
#include <iostream>
|
||||
using namespace std;
|
||||
int main()
|
||||
{
|
||||
long long n, a, b, ans;
|
||||
while( cin >> n, n )
|
||||
{
|
||||
n--;
|
||||
a = n/3;
|
||||
b = n%3;
|
||||
ans = a*2+1;
|
||||
if( b == 2 ) ans++;
|
||||
cout << ans << endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,68 @@
|
|||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<iostream>
|
||||
#include<algorithm>
|
||||
#include<vector>
|
||||
using namespace std;
|
||||
vector<int>v[20][20];
|
||||
int n,m,k;
|
||||
int q[1005];
|
||||
char ch[22];
|
||||
bool work(int a)
|
||||
{
|
||||
int i,j;
|
||||
int res=0;
|
||||
for(i=0;i<v[m][a].size();i++)
|
||||
{ res=0;
|
||||
for(j=1;j<=n;j++)
|
||||
{
|
||||
if((v[m][a][i]^q[j])==v[m][a][i]+q[j])
|
||||
{
|
||||
res++;
|
||||
}
|
||||
}
|
||||
if(res>=k) return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int i,j,a,b,c;
|
||||
v[1][0].push_back(0);
|
||||
v[1][1].push_back(1);
|
||||
for(i=2;i<=15;i++)
|
||||
{
|
||||
for(j=0;j<i;j++)
|
||||
{
|
||||
for(int k=0;k<v[i-1][j].size();k++)
|
||||
{
|
||||
v[i][j].push_back(v[i-1][j][k]<<1);
|
||||
v[i][j+1].push_back(v[i-1][j][k]<<1^1);
|
||||
}
|
||||
}
|
||||
}
|
||||
while(scanf("%d%d%d",&n,&m,&k)!=EOF)
|
||||
{
|
||||
for(i=1;i<=n;i++)
|
||||
{
|
||||
q[i]=(1<<m)-1;
|
||||
scanf("%s %d",ch,&a);
|
||||
for(j=0;j<a;j++)
|
||||
{
|
||||
scanf("%d",&b);
|
||||
q[i]^=(1<<(b-1));
|
||||
}
|
||||
}
|
||||
int l=0,r=m,mid;
|
||||
while(l+1<r)
|
||||
{
|
||||
mid=(l+r)>>1;
|
||||
if(work(mid)) l=mid;
|
||||
else
|
||||
r=mid-1;
|
||||
}
|
||||
if(work(r)) { printf("%d\n",r);}
|
||||
else printf("%d\n",l);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,74 @@
|
|||
#include<iostream>
|
||||
#include<climits>
|
||||
using namespace std;
|
||||
const int maxn=85;
|
||||
int N,M,K,X,Y;
|
||||
int matrix[maxn][maxn][maxn];
|
||||
int t[maxn][maxn];
|
||||
int dis[maxn][maxn];
|
||||
bool judge(int a,int b,int c)
|
||||
{
|
||||
int i,j,k;
|
||||
for(i=1;i<=M;++i)
|
||||
{
|
||||
t[0][i]=0;
|
||||
for(j=1;j<=M;++j)
|
||||
t[0][i]+=matrix[a][i][j]*t[b][j];
|
||||
}
|
||||
for(i=1;i<=M;++i)
|
||||
if(t[0][i]!=t[c][i])
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int i,j,k;
|
||||
while(cin>>N>>M&&(M+N))
|
||||
{
|
||||
for(i=1;i<=N;++i)
|
||||
for(j=i+1;j<=N;++j)
|
||||
dis[i][j]=dis[j][i]=INT_MAX;
|
||||
for(i=1;i<=N;++i)
|
||||
for(j=1;j<=M;++j)
|
||||
{
|
||||
t[i][j]=0;
|
||||
for(k=1;k<=M;++k)
|
||||
{
|
||||
cin>>matrix[i][j][k];
|
||||
t[i][j]+=matrix[i][j][k]*k;
|
||||
}
|
||||
}
|
||||
for(i=1;i<=N;++i)
|
||||
for(j=1;j<=N;++j)
|
||||
{
|
||||
if(i==j)
|
||||
continue;
|
||||
for(k=1;k<=N;++k)
|
||||
{
|
||||
if(i==k||j==k||dis[i][k]==1)
|
||||
continue;
|
||||
if(judge(i,j,k))
|
||||
dis[i][k]=1;
|
||||
}
|
||||
}
|
||||
for(k=1;k<=N;++k)
|
||||
for(i=1;i<=N;++i)
|
||||
{
|
||||
if(dis[i][k]==INT_MAX)
|
||||
continue;
|
||||
for(j=1;j<=N;++j)
|
||||
if(dis[k][j]<INT_MAX&&dis[i][k]+dis[k][j]<dis[i][j])
|
||||
dis[i][j]=dis[i][k]+dis[k][j];
|
||||
}
|
||||
cin>>K;
|
||||
for(i=1;i<=K;++i)
|
||||
{
|
||||
cin>>X>>Y;
|
||||
if(dis[X][Y]==INT_MAX)
|
||||
cout<<"Sorry"<<endl;
|
||||
else
|
||||
cout<<dis[X][Y]<<endl;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,69 @@
|
|||
# include<stdio.h>
|
||||
# include<string.h>
|
||||
# define INF 0xfffffff
|
||||
int n,m;
|
||||
struct node{
|
||||
int ati,def,hp,exp;
|
||||
}str[21];
|
||||
int s[21]={1,2,4,8,16,32,64,128,256,512,1024,2048,4096,8192,16384,32768,65536,131072,262144,524288,1048576};
|
||||
struct node1{
|
||||
int ati,def,hp,exp;
|
||||
}DP[1049000];
|
||||
int max(int a,int b)
|
||||
{
|
||||
return a>b?a:b;
|
||||
}
|
||||
int judge(int a1,int b1,int c1,int a2,int b2,int c2)
|
||||
{
|
||||
int ans1,ans2,num1,num2;
|
||||
ans1=max(1,a1-b2);
|
||||
ans2=max(1,a2-b1);
|
||||
num1=c1/ans2;
|
||||
if(num1*ans2!=c1) num1++;
|
||||
num2=c2/ans1;
|
||||
if(num2*ans1!=c2) num2++;
|
||||
if(num2>num1) return 0;
|
||||
c1-=(num2-1)*ans2;
|
||||
return c1;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int i,j,in_ati,in_def,in_hp,ati,def,hp,num,temp,ans;
|
||||
char ch[105];
|
||||
while(scanf("%d%d%d %d%d%d",&ati,&def,&hp,&in_ati,&in_def,&in_hp)!=EOF)
|
||||
{
|
||||
scanf("%d",&n);
|
||||
for(i=0;i<n;i++)
|
||||
scanf("%s %d%d%d%d",&ch,&str[i].ati,&str[i].def,&str[i].hp,&str[i].exp);
|
||||
DP[0].hp=hp;
|
||||
DP[0].exp=0;
|
||||
DP[0].ati=ati;
|
||||
DP[0].def=def;
|
||||
for(i=1;i<s[n];i++)
|
||||
{
|
||||
DP[i].hp=-1;
|
||||
for(j=0;j<n;j++)
|
||||
{
|
||||
if(i&s[j])
|
||||
{
|
||||
ans=i-s[j];
|
||||
if(DP[ans].hp==-1) continue;
|
||||
temp=judge(DP[ans].ati,DP[ans].def,DP[ans].hp,str[j].ati,str[j].def,str[j].hp);
|
||||
if(temp==0) continue;
|
||||
num=DP[ans].exp+str[j].exp;
|
||||
num/=100;
|
||||
if(DP[i].hp<temp +num*in_hp)
|
||||
{
|
||||
DP[i].hp=temp+num*in_hp;
|
||||
DP[i].ati=DP[ans].ati+num*in_ati;
|
||||
DP[i].def=DP[ans].def+num*in_def;
|
||||
DP[i].exp=(DP[ans].exp+str[j].exp)%100;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if(DP[s[n]-1].hp==-1) printf("Poor LvBu,his period was gone.\n");
|
||||
else printf("%d\n",DP[s[n]-1].hp);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,43 @@
|
|||
#include<stdio.h>
|
||||
__int64 mmg[1005],n,k;
|
||||
__int64 C[1005][1000],flag[1005][1000];
|
||||
int main()
|
||||
{
|
||||
int i,j;
|
||||
while(scanf("%I64d%I64d",&n,&k)!=EOF)
|
||||
{
|
||||
C[1][0]=C[1][1]=1%k;
|
||||
flag[1][0]=flag[1][1]=(1/k)%2;
|
||||
for(i=2;i<=n;i++)
|
||||
{
|
||||
C[i][0]=C[i][i]=1%k;
|
||||
flag[i][0]=flag[i][i]=(1/k)%2;
|
||||
for(j=1;j<i;j++)
|
||||
{
|
||||
C[i][j]=(C[i-1][j]+C[i-1][j-1])%k;
|
||||
flag[i][j]=flag[i-1][j]+flag[i-1][j-1]+(C[i-1][j]+C[i-1][j-1])/k;
|
||||
flag[i][j]=flag[i][j]%2;
|
||||
}
|
||||
}
|
||||
mmg[1]=1%k;
|
||||
mmg[2]=1%k;
|
||||
for(i=3;i<=n;i++)
|
||||
{
|
||||
mmg[i]=mmg[i-1];
|
||||
for(j=1;j<=(i-1)/2;j++)
|
||||
{
|
||||
if(i-1==2*j)
|
||||
{
|
||||
if(flag[i-1][j]==1)
|
||||
mmg[i]+=(((mmg[j]%k)*(mmg[i-j-1]%k))%k)*(((C[i-1][j]+k)/2)%k);
|
||||
else
|
||||
mmg[i]+=(((mmg[j]%k)*(mmg[i-j-1]%k))%k)*(((C[i-1][j])/2)%k);
|
||||
}
|
||||
else
|
||||
mmg[i]+=(((mmg[j]%k)*(mmg[i-j-1]%k))%k)*(C[i-1][j]%k);
|
||||
mmg[i]=mmg[i]%k;
|
||||
}
|
||||
}
|
||||
printf("%I64d\n",mmg[n]);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,71 @@
|
|||
#include<iostream>
|
||||
#include<cstring>
|
||||
#include<cstdio>
|
||||
#include<cmath>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
double pin[15];
|
||||
bool judge()
|
||||
{
|
||||
if(fabs(pin[14] - 5) < 1e-16 && (pin[7] >= 0 && pin[7] <= 0.8))
|
||||
return true;
|
||||
else
|
||||
return false;
|
||||
}
|
||||
bool gaodi(double a)
|
||||
{
|
||||
int temp;
|
||||
if(a >= 0.0 && a <= 0.8)
|
||||
return 0; //low
|
||||
else
|
||||
return 1; //high
|
||||
}
|
||||
char cal(double a, double b)
|
||||
{
|
||||
if(gaodi(a) && gaodi(b))
|
||||
return 'L';
|
||||
else
|
||||
return 'H';
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int n;
|
||||
int a;
|
||||
double dianya;
|
||||
while(scanf("%d", &n) != EOF)
|
||||
{
|
||||
for(int i = 1; i <= 14; ++i)
|
||||
pin[i] = -1.0;
|
||||
for(int i = 0; i < n; ++i)
|
||||
{
|
||||
scanf("%d%lf", &a, &dianya);
|
||||
pin[a] = dianya;
|
||||
}
|
||||
if(!judge())
|
||||
{
|
||||
printf("No\n");
|
||||
continue;
|
||||
}
|
||||
else
|
||||
{
|
||||
printf("Yes\n");
|
||||
if(pin[1] != -1 && pin[2] != -1)
|
||||
{
|
||||
printf("3 %c\n", cal(pin[1], pin[2]));
|
||||
}
|
||||
if(pin[4] != -1 && pin[5] != -1)
|
||||
{
|
||||
printf("6 %c\n", cal(pin[4], pin[5]));
|
||||
}
|
||||
if(pin[9] != -1 && pin[10] != -1)
|
||||
{
|
||||
printf("8 %c\n", cal(pin[9], pin[10]));
|
||||
}
|
||||
if(pin[12] != -1 && pin[13] != -1)
|
||||
{
|
||||
printf("11 %c\n", cal(pin[12], pin[13]));
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,86 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
#include<map>
|
||||
#include<iostream>
|
||||
using namespace std;
|
||||
map<string,int>q;
|
||||
const int M=201;
|
||||
const int inf=999999999;
|
||||
int Map[M][M],match[M],lx[M],ly[M],vx[M],vy[M];
|
||||
int n,m;
|
||||
int hungery(int u)
|
||||
{
|
||||
int i;
|
||||
vx[u]=1;
|
||||
for(i=1;i<=m;i++)
|
||||
{
|
||||
if(!vy[i]&&lx[u]+ly[i]==Map[u][i])
|
||||
{
|
||||
vy[i]=1;
|
||||
if(match[i]==-1||hungery(match[i]))
|
||||
{
|
||||
match[i]=u;
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
void KM()
|
||||
{
|
||||
int i,temp,j;
|
||||
for(i=1;i<=n;i++)
|
||||
for(j=1;j<=m;j++)
|
||||
lx[i]=max(lx[i],Map[i][j]);
|
||||
memset(ly,0,sizeof(ly));
|
||||
memset(match,-1,sizeof(match));
|
||||
for(i=1;i<=n;i++)
|
||||
{
|
||||
while(1)
|
||||
{
|
||||
memset(vx,0,sizeof(vx));
|
||||
memset(vy,0,sizeof(vy));
|
||||
if(hungery(i))
|
||||
break;
|
||||
temp=inf;
|
||||
for(j=1;j<=n;j++)
|
||||
if(vx[j])
|
||||
for(int z=1;z<=m;z++)
|
||||
if(!vy[z]&&temp>lx[j]+ly[z]-Map[j][z])
|
||||
temp=lx[j]+ly[z]-Map[j][z];
|
||||
for(j=1;j<=n;j++)
|
||||
if(vx[j])
|
||||
lx[j]-=temp;
|
||||
for(j=1;j<=m;j++)
|
||||
if(vy[j])
|
||||
ly[j]+=temp;
|
||||
}
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int i,k,w,num1,num2,j;
|
||||
char s1[21],s2[21];
|
||||
while(~scanf("%d%d%d",&n,&m,&k))
|
||||
{
|
||||
for(i=1;i<=n;i++)
|
||||
for(j=1;j<=m;j++)
|
||||
Map[i][j]=-inf;
|
||||
num1=num2=0;
|
||||
for(i=1;i<=k;i++)
|
||||
{
|
||||
scanf("%s%s%d",s1,s2,&w);
|
||||
if(q[s1]==0)
|
||||
q[s1]=++num1;
|
||||
if(q[s2]==0)
|
||||
q[s2]=++num2;
|
||||
Map[q[s1]][q[s2]]=-w;
|
||||
}
|
||||
KM();
|
||||
int sum=0;
|
||||
for(i=1;i<=m;i++)
|
||||
if(match[i]!=-1&&Map[match[i]][i]!=-inf)
|
||||
sum+=Map[match[i]][i];
|
||||
printf("%d\n",-sum);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,133 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
#include <cmath>
|
||||
#include <iostream>
|
||||
using namespace std;
|
||||
typedef unsigned __int64 LL;
|
||||
struct Matrix
|
||||
{
|
||||
LL m[3][3];
|
||||
}E, D;
|
||||
LL Pow(LL a, LL b, LL mod)
|
||||
{
|
||||
LL ans = 1;
|
||||
while (b)
|
||||
{
|
||||
if (b & 1)
|
||||
{
|
||||
b--;
|
||||
ans = (ans*a)%mod;
|
||||
}
|
||||
else
|
||||
{
|
||||
b /= 2;
|
||||
a = (a*a)%mod;
|
||||
}
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
void init()
|
||||
{
|
||||
for (int i = 1; i <= 2; i++)
|
||||
for (int j = 1; j <= 2; j++)
|
||||
{
|
||||
D.m[i][j] = 1;
|
||||
E.m[i][j] = (i == j);
|
||||
}
|
||||
D.m[2][2] = 0;
|
||||
}
|
||||
Matrix Multi(Matrix A, Matrix B, LL mod)
|
||||
{
|
||||
Matrix ans;
|
||||
for (int i = 1; i <= 2; i++)
|
||||
for (int j = 1; j <= 2; j++)
|
||||
{
|
||||
ans.m[i][j] = 0;
|
||||
for (int k = 1; k <= 2; k++)
|
||||
ans.m[i][j] = (ans.m[i][j] + A.m[i][k] * B.m[k][j])%mod;
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
Matrix Pow(Matrix A, LL k, LL mod)
|
||||
{
|
||||
Matrix ans = E;
|
||||
while (k)
|
||||
{
|
||||
if (k & 1)
|
||||
{
|
||||
k--;
|
||||
ans = Multi(ans, A, mod);
|
||||
}
|
||||
else
|
||||
{
|
||||
k /= 2;
|
||||
A = Multi(A, A, mod);
|
||||
}
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
LL Fib(LL n, LL mod)
|
||||
{
|
||||
return Pow(D, n, mod).m[2][1];
|
||||
}
|
||||
long long euler(long long x)
|
||||
{
|
||||
long long i, res = x;
|
||||
for (i = 2; i*i <= x; i++)
|
||||
if (x%i == 0)
|
||||
{
|
||||
res = res / i*(i - 1);
|
||||
while (x%i == 0)
|
||||
x /= i;
|
||||
}
|
||||
if (x > 1)
|
||||
res = res / x*(x - 1);
|
||||
return res;
|
||||
}
|
||||
LL s_mod(LL n)
|
||||
{
|
||||
LL a1 = 0, a2 = 1, a3 = 1, tmp, ans = 1;
|
||||
while (a2 != 0 || a3 != 1)
|
||||
{
|
||||
ans++;
|
||||
tmp = (a2 + a3)%n;
|
||||
a2 = a3;
|
||||
a3 = tmp;
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
LL smod[305];
|
||||
int main()
|
||||
{
|
||||
init();
|
||||
smod[1] = 1;
|
||||
for (int i = 2; i <= 300; i++)
|
||||
smod[i] = s_mod(i);
|
||||
LL a, b, n;
|
||||
int c;
|
||||
int t;
|
||||
scanf("%d", &t);
|
||||
LL mod1, mod2, tmp, cnt, ans, eul;
|
||||
for (int cas = 1; cas <= t; cas++)
|
||||
{
|
||||
scanf("%I64u%I64u%I64u%d", &a, &b, &n, &c);
|
||||
if (c == 1)
|
||||
{
|
||||
printf("Case %d: 0\n", cas);
|
||||
continue;
|
||||
}
|
||||
mod1 = smod[c];
|
||||
eul = euler(c);
|
||||
mod2 = smod[eul];
|
||||
tmp = Pow(a%mod1, b, mod1);
|
||||
tmp = Fib(tmp, c);
|
||||
cnt = Pow(a%mod2, b, mod2);
|
||||
cnt = Fib(cnt, eul);
|
||||
cnt = Pow(cnt, n - 1, eul);
|
||||
cnt += eul;
|
||||
ans = Pow(tmp, cnt, c);
|
||||
printf("Case %d: %I64u\n", cas, ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,109 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<algorithm>
|
||||
#include<cmath>
|
||||
#define LL __int64
|
||||
#define N 1000000
|
||||
using namespace std;
|
||||
struct Node{
|
||||
int idx;
|
||||
int val;
|
||||
}baby[N];
|
||||
bool cmp(Node n1,Node n2){
|
||||
return n1.val!=n2.val?n1.val<n2.val:n1.idx<n2.idx;
|
||||
}
|
||||
int gcd(int a,int b){
|
||||
return b==0?a:gcd(b,a%b);
|
||||
}
|
||||
int extend_gcd(int a,int b,int &x,int &y){
|
||||
if(b==0){
|
||||
x=1;
|
||||
y=0;
|
||||
return a;
|
||||
}
|
||||
int gcd=extend_gcd(b,a%b,x,y);
|
||||
int t=x;
|
||||
x=y;
|
||||
y=t-a/b*y;
|
||||
return gcd;
|
||||
}
|
||||
int inval(int a,int b,int n){
|
||||
int e,x,y;
|
||||
extend_gcd(a,n,x,y);
|
||||
e=((LL)x*b)%n;
|
||||
return e<0?e+n:e;
|
||||
}
|
||||
int PowMod(int a,int b,int MOD){
|
||||
LL ret=1%MOD,t=a%MOD;
|
||||
while(b){
|
||||
if(b&1)
|
||||
ret=((LL)ret*t)%MOD;
|
||||
t=((LL)t*t)%MOD;
|
||||
b>>=1;
|
||||
}
|
||||
return (int)ret;
|
||||
}
|
||||
int BinSearch(int num,int m){
|
||||
int low=0,high=m-1,mid;
|
||||
while(low<=high){
|
||||
mid=(low+high)>>1;
|
||||
if(baby[mid].val==num)
|
||||
return baby[mid].idx;
|
||||
if(baby[mid].val<num)
|
||||
low=mid+1;
|
||||
else
|
||||
high=mid-1;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
int BabyStep(int A,int B,int C){
|
||||
LL tmp,D=1%C;
|
||||
int temp;
|
||||
for(int i=0,tmp=1%C;i<100;i++,tmp=((LL)tmp*A)%C)
|
||||
if(tmp==B)
|
||||
return i;
|
||||
int d=0;
|
||||
while((temp=gcd(A,C))!=1){
|
||||
if(B%temp) return -1;
|
||||
d++;
|
||||
C/=temp;
|
||||
B/=temp;
|
||||
D=((A/temp)*D)%C;
|
||||
}
|
||||
int m=(int)ceil(sqrt((double)C));
|
||||
for(int i=0,tmp=1%C;i<=m;i++,tmp=((LL)tmp*A)%C){
|
||||
baby[i].idx=i;
|
||||
baby[i].val=tmp;
|
||||
}
|
||||
sort(baby,baby+m+1,cmp);
|
||||
int cnt=1;
|
||||
for(int i=1;i<=m;i++)
|
||||
if(baby[i].val!=baby[cnt-1].val)
|
||||
baby[cnt++]=baby[i];
|
||||
int am=PowMod(A,m,C);
|
||||
for(int i=0;i<=m;i++,D=((LL)(D*am))%C){
|
||||
int tmp=inval(D,B,C);
|
||||
if(tmp>=0){
|
||||
int pos=BinSearch(tmp,cnt);
|
||||
if(pos!=-1)
|
||||
return i*m+pos+d;
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
int main(){
|
||||
int A,B,C;
|
||||
while(scanf("%d%d%d",&A,&C,&B)!=EOF){
|
||||
if(B>=C){
|
||||
puts("Orz,I cant find D!");
|
||||
continue;
|
||||
}
|
||||
int ans=BabyStep(A,B,C);
|
||||
if(ans==-1)
|
||||
puts("Orz,I cant find D!");
|
||||
else
|
||||
printf("%d\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,61 @@
|
|||
#include<iostream>
|
||||
#include<cstdlib>
|
||||
#include<cstdio>
|
||||
#include<string.h>
|
||||
#include<map>
|
||||
using namespace std;
|
||||
char s[1024];
|
||||
int rec[506],word[506];
|
||||
int main()
|
||||
{
|
||||
map<int,char> mp;
|
||||
mp[21]='K';
|
||||
mp[22]='X';
|
||||
mp[23]='V';
|
||||
mp[31]='M';
|
||||
mp[32]='C';
|
||||
mp[33]='N';
|
||||
mp[41]='O';
|
||||
mp[42]='P';
|
||||
mp[43]='H';
|
||||
mp[51]='Q';
|
||||
mp[52]='R';
|
||||
mp[53]='S';
|
||||
mp[61]='Z';
|
||||
mp[62]='Y';
|
||||
mp[63]='I';
|
||||
mp[71]='J';
|
||||
mp[72]='A';
|
||||
mp[73]='D';
|
||||
mp[74]='L';
|
||||
mp[81]='E';
|
||||
mp[82]='G';
|
||||
mp[83]='W';
|
||||
mp[91]='B';
|
||||
mp[92]='U';
|
||||
mp[93]='F';
|
||||
mp[94]='T';
|
||||
while(scanf("%s",s)!=EOF) {
|
||||
int len = strlen(s),cnt = 0;
|
||||
memset(rec,0,sizeof(rec));
|
||||
for(int i = 0; i < len; i += 2,cnt++) {
|
||||
rec[cnt] = s[i] - '0';
|
||||
rec[cnt] = rec[cnt] * 10 + s[i+1] - '0';
|
||||
}
|
||||
int lim = (cnt-1)>>1;
|
||||
for(int i = lim, j = cnt - 1, k = 0; i >= 0; --i,--j,k += 2) {
|
||||
if(cnt & 1) {
|
||||
word[k] = rec[i];
|
||||
word[k+1] = rec[j];
|
||||
}else {
|
||||
word[k] = rec[j];
|
||||
word[k+1] = rec[i];
|
||||
}
|
||||
}
|
||||
for(int i = 0; i < cnt; ++i) {
|
||||
printf("%c",mp[word[i]]);
|
||||
}
|
||||
puts("");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,41 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cstring>
|
||||
using namespace std;
|
||||
const int M=200907;
|
||||
int main()
|
||||
{
|
||||
__int64 a1,a2,a3,q;
|
||||
int n,T;
|
||||
__int64 ans;
|
||||
scanf("%d",&T);
|
||||
while(T--)
|
||||
{
|
||||
scanf("%I64d%I64d%I64d%d",&a1,&a2,&a3,&n);
|
||||
if(a2-a1==a3-a2)
|
||||
{
|
||||
q=a2-a1;
|
||||
ans=(a1%M+(((n-1)%M)*(q%M))%M)%M;
|
||||
}
|
||||
else
|
||||
{
|
||||
q=(a2/a1)%M;
|
||||
long long temp=1;
|
||||
n--;
|
||||
a1=a1%M;
|
||||
while(n)
|
||||
{
|
||||
if(n&1)
|
||||
{
|
||||
temp=temp*q;
|
||||
temp%=M;
|
||||
}
|
||||
q=(q*q)%M;
|
||||
n/=2;
|
||||
}
|
||||
ans=(a1*temp)%M;
|
||||
}
|
||||
printf("%I64d\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,58 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<algorithm>
|
||||
#include<cmath>
|
||||
#include<string>
|
||||
#include<memory.h>
|
||||
#include<cstring>
|
||||
using namespace std;
|
||||
int father[30002],low[30002],high[30002];
|
||||
int find(int x)
|
||||
{
|
||||
if(x==father[x])
|
||||
return x;
|
||||
int dx=find(father[x]);
|
||||
low[x]+=low[father[x]];
|
||||
return father[x]=dx;
|
||||
}
|
||||
void clear()
|
||||
{
|
||||
for(int i=0;i<30002;i++)
|
||||
{
|
||||
father[i]=i;
|
||||
high[i]=1;
|
||||
}
|
||||
memset(low,0,sizeof(low));
|
||||
}
|
||||
int main()
|
||||
{
|
||||
char ch;
|
||||
int a,b,n;
|
||||
while(cin>>n)
|
||||
{
|
||||
getchar();
|
||||
clear();
|
||||
while(n--)
|
||||
{
|
||||
cin>>ch;
|
||||
if(ch=='M')
|
||||
{
|
||||
scanf("%d %d%*c",&a,&b);
|
||||
int x=find(a);
|
||||
int y=find(b);
|
||||
if(x==y)
|
||||
continue;
|
||||
father[x]=y;
|
||||
low[x]=high[y];
|
||||
high[y]+=high[x];
|
||||
}
|
||||
if(ch=='C')
|
||||
{
|
||||
scanf("%d%*c",&a);
|
||||
find(a);
|
||||
cout<<low[a]<<endl;
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,67 @@
|
|||
#include <map>
|
||||
#include <set>
|
||||
#include <stack>
|
||||
#include <queue>
|
||||
#include <cmath>
|
||||
#include <ctime>
|
||||
#include <vector>
|
||||
#include <cstdio>
|
||||
#include <cctype>
|
||||
#include <cstring>
|
||||
#include <cstdlib>
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
#define eps 1e-15
|
||||
#define MAXN 105
|
||||
#define INF 1000000007
|
||||
#define MAX(a,b) (a > b ? a : b)
|
||||
#define MIN(a,b) (a < b ? a : b)
|
||||
#define mem(a) memset(a,0,sizeof(a))
|
||||
bool G[MAXN][MAXN],vis[MAXN];
|
||||
int Left[MAXN],N,M,T,a[MAXN],b[MAXN];
|
||||
bool DFS(int u)
|
||||
{
|
||||
for(int v=0;v<=N;v++) if(G[u][v] && !vis[v])
|
||||
{
|
||||
vis[v] = true;
|
||||
if(!Left[v] || DFS(Left[v]))
|
||||
{
|
||||
Left[v] = u;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
while(~scanf("%d", &N))
|
||||
{
|
||||
mem(G); mem(Left);
|
||||
int x,ans = 0;
|
||||
for(int i=1;i<=N;i++) for(int j=1;j<=N;j++)
|
||||
{
|
||||
scanf("%d", &x);
|
||||
if(x)G[i][j] = true;
|
||||
}
|
||||
for(int i=1;i<=N;i++)
|
||||
{
|
||||
mem(vis);
|
||||
if(DFS(i)) ans ++;
|
||||
}
|
||||
if(ans < N){printf("-1\n");continue;}
|
||||
int tot = 0,j;
|
||||
for(int i=1;i<=N;i++)
|
||||
{
|
||||
for(j=1;j<=N && Left[j]!=i ;j++);
|
||||
if(i != j)
|
||||
{
|
||||
a[tot] = i; b[tot] = j; tot ++;
|
||||
int t = Left[i]; Left[i] = Left[j]; Left[j] = t;
|
||||
}
|
||||
}
|
||||
printf("%d\n",tot);
|
||||
for(int i=0;i<tot;i++) printf("C %d %d\n", a[i],b[i]);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,125 @@
|
|||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<cstdlib>
|
||||
#include<cmath>
|
||||
#include<algorithm>
|
||||
#include<iostream>
|
||||
using namespace std;
|
||||
typedef long long LL;
|
||||
const LL PP=1000000007;
|
||||
const int P=10007;
|
||||
struct Node
|
||||
{
|
||||
int len;
|
||||
int va[12];
|
||||
};
|
||||
LL dp[2][110000];
|
||||
Node ST[2][110000];
|
||||
struct Edge{int ne,id;Node st;}e[110000];
|
||||
int p[P+10],mod[P+10],Hashnum;
|
||||
void Hashinit()
|
||||
{
|
||||
memset(p,-1,sizeof(p));
|
||||
memset(mod,0,sizeof(mod));
|
||||
Hashnum=0;
|
||||
}
|
||||
int find(Node st,int re)
|
||||
{
|
||||
if(mod[re])
|
||||
{
|
||||
for(int i=p[re];i!=-1;i=e[i].ne)
|
||||
{
|
||||
if(e[i].st.len!=st.len)continue;
|
||||
for(int j=0;j<st.len;j++)
|
||||
if(e[i].st.va[j]!=st.va[j])continue;
|
||||
return e[i].id;
|
||||
}
|
||||
}
|
||||
mod[re]=1;
|
||||
e[Hashnum].st.len=st.len;
|
||||
for(int i=0;i<st.len;i++)
|
||||
e[Hashnum].st.va[i]=st.va[i];
|
||||
e[Hashnum].id=Hashnum;e[Hashnum].ne=p[re];
|
||||
p[re]=Hashnum++;
|
||||
return Hashnum-1;
|
||||
}
|
||||
int num[120];
|
||||
void add(Node st,LL va,int id)
|
||||
{
|
||||
int re=st.len;
|
||||
for(int i=0;i<st.len;i++)
|
||||
{
|
||||
re*=12;
|
||||
re+=st.va[i];
|
||||
re%=P;
|
||||
}
|
||||
int tt=find(st,re);
|
||||
if(tt+1>num[id])
|
||||
{
|
||||
ST[id][tt].len=st.len;
|
||||
for(int i=0;i<st.len;i++)
|
||||
ST[id][tt].va[i]=st.va[i];
|
||||
num[id]=tt+1;
|
||||
}
|
||||
dp[id][tt]+=va;
|
||||
dp[id][tt]%=PP;
|
||||
}
|
||||
int n,K,i,j,k,l,fl,te,po;
|
||||
int main()
|
||||
{
|
||||
while(~scanf("%d%d",&n,&K))
|
||||
{
|
||||
if(K==0){puts("0");continue;}
|
||||
num[0]=1;fl=0;num[1]=0;
|
||||
ST[0][0].len=1;
|
||||
ST[0][0].va[0]=1;
|
||||
memset(dp,0,sizeof(dp));dp[0][0]=1;
|
||||
for(i=2;i<=n;i++)
|
||||
{
|
||||
te=1-fl;
|
||||
for(j=0;j<num[te];j++)
|
||||
dp[te][j]=0;
|
||||
num[te]=0;
|
||||
Hashinit();
|
||||
for(j=0;j<num[fl];j++)
|
||||
{
|
||||
Node ts=ST[fl][j];
|
||||
for(k=0;k<=ts.len;k++)
|
||||
{
|
||||
bool can=true;
|
||||
if(k!=0&&ts.va[k-1]==0)can=false;
|
||||
if(k!=ts.len&&ts.va[k]==0)can=false;
|
||||
if(!can)continue;
|
||||
Node tt;
|
||||
for(l=0;l<k;l++)
|
||||
{
|
||||
if(ts.va[l]!=0)tt.va[l]=(ts.va[l]+1)%(K+1);
|
||||
else tt.va[l]=0;
|
||||
}
|
||||
tt.va[k]=1;
|
||||
for(l=ts.len;l>k;l--)
|
||||
{
|
||||
if(ts.va[l-1]!=0)tt.va[l]=(ts.va[l-1]+1)%(K+1);
|
||||
else tt.va[l]=0;
|
||||
}
|
||||
tt.len=ts.len+1;po=1;
|
||||
for(l=1;l<=ts.len;l++)
|
||||
{
|
||||
if(tt.va[l]==0&tt.va[po-1]==0)continue;
|
||||
else tt.va[po++]=tt.va[l];
|
||||
}
|
||||
tt.len=po;
|
||||
add(tt,dp[fl][j],te);
|
||||
}
|
||||
}
|
||||
fl=te;
|
||||
}
|
||||
LL ans=0;
|
||||
for(i=0;i<num[fl];i++)
|
||||
{
|
||||
ans+=dp[fl][i];
|
||||
ans%=PP;
|
||||
}
|
||||
cout<<ans<<endl;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,170 @@
|
|||
#include <cstdio>
|
||||
#include <iostream>
|
||||
#include <deque>
|
||||
#define M 28
|
||||
using namespace std;
|
||||
int n,m,res,found;
|
||||
int mp[M][M];
|
||||
deque<char>deq;
|
||||
void dfs(int y,int x){
|
||||
if(res==0){
|
||||
found=1;
|
||||
return;
|
||||
}
|
||||
if(found)return;
|
||||
int flag=0,i;
|
||||
for(i=y-2;i>=0;i--)
|
||||
if(mp[i][x]){
|
||||
flag=1;
|
||||
break;
|
||||
}
|
||||
if(y>0&&mp[y-1][x])flag=0;
|
||||
if(flag){
|
||||
int d=mp[i][x];
|
||||
if(i==0){
|
||||
res-=mp[i][x];
|
||||
mp[i][x]=0;
|
||||
deq.push_back('U');
|
||||
dfs(i,x);if(found)return;
|
||||
mp[i][x]=d;
|
||||
deq.pop_back();
|
||||
res+=mp[i][x];
|
||||
}
|
||||
else {
|
||||
res--;
|
||||
mp[i][x]=0;
|
||||
deq.push_back('U');
|
||||
mp[i-1][x]+=d-1;
|
||||
dfs(i,x);if(found)return;
|
||||
mp[i][x]=d;
|
||||
mp[i-1][x]-=d-1;
|
||||
deq.pop_back();
|
||||
res++;
|
||||
}
|
||||
}
|
||||
flag=0;
|
||||
for(i=y+2;i<n;i++)
|
||||
if(mp[i][x]){
|
||||
flag=1;
|
||||
break;
|
||||
}
|
||||
if(y<n-1&&mp[y+1][x])flag=0;
|
||||
if(flag){
|
||||
int d=mp[i][x];
|
||||
if(i==n-1){
|
||||
res-=mp[i][x];
|
||||
mp[i][x]=0;
|
||||
deq.push_back('D');
|
||||
dfs(i,x);if(found)return;
|
||||
mp[i][x]=d;
|
||||
deq.pop_back();
|
||||
res+=mp[i][x];
|
||||
}
|
||||
else {
|
||||
res--;
|
||||
mp[i][x]=0;
|
||||
deq.push_back('D');
|
||||
mp[i+1][x]+=d-1;
|
||||
dfs(i,x);if(found)return;
|
||||
mp[i][x]=d;
|
||||
deq.pop_back();
|
||||
mp[i+1][x]-=d-1;
|
||||
res++;
|
||||
}
|
||||
}
|
||||
flag=0;
|
||||
for(i=x-2;i>=0;i--)
|
||||
if(mp[y][i]){
|
||||
flag=1;
|
||||
break;
|
||||
}
|
||||
if(x>0&&mp[y][x-1])flag=0;
|
||||
if(flag){
|
||||
int d=mp[y][i];
|
||||
if(i==0){
|
||||
mp[y][i]=0;
|
||||
deq.push_back('L');
|
||||
res-=d;
|
||||
dfs(y,i);if(found)return;
|
||||
deq.pop_back();
|
||||
res+=d;
|
||||
mp[y][i]=d;
|
||||
}
|
||||
else {
|
||||
mp[y][i]=0;
|
||||
deq.push_back('L');
|
||||
res--;
|
||||
mp[y][i-1]+=d-1;
|
||||
dfs(y,i);if(found)return;
|
||||
deq.pop_back();
|
||||
res++;
|
||||
mp[y][i]=d;
|
||||
mp[y][i-1]-=d-1;
|
||||
}
|
||||
}
|
||||
flag=0;
|
||||
for(i=x+2;i<m;i++)
|
||||
if(mp[y][i]){
|
||||
flag=1;
|
||||
break;
|
||||
}
|
||||
if(x<m-1&&mp[y][x+1])flag=0;
|
||||
if(flag){
|
||||
int d=mp[y][i];
|
||||
if(i==m-1){
|
||||
mp[y][i]=0;
|
||||
deq.push_back('R');
|
||||
res-=d;
|
||||
dfs(y,i);if(found)return;
|
||||
deq.pop_back();
|
||||
res+=d;
|
||||
mp[y][i]=d;
|
||||
}
|
||||
else {
|
||||
mp[y][i]=0;
|
||||
deq.push_back('R');
|
||||
res--;
|
||||
mp[y][i+1]+=d-1;
|
||||
dfs(y,i);if(found)return;
|
||||
deq.pop_back();
|
||||
res++;
|
||||
mp[y][i]=d;
|
||||
mp[y][i+1]-=d-1;
|
||||
}
|
||||
}
|
||||
}
|
||||
int main(void){
|
||||
while(~scanf("%d%d",&m,&n)){
|
||||
res=0;
|
||||
char c;
|
||||
for(int i=0;i<n;i++){
|
||||
getchar();
|
||||
for(int j=0;j<m;j++){
|
||||
c=getchar();
|
||||
if(c!='.'){
|
||||
mp[i][j]=(c-'a')+1;
|
||||
res+=(c-'a')+1;
|
||||
}
|
||||
else mp[i][j]=0;
|
||||
}
|
||||
}
|
||||
found=0;
|
||||
for(int i=0;i<n;i++){
|
||||
for(int j=0;j<m;j++){
|
||||
if(mp[i][j]!=0)continue;
|
||||
dfs(i,j);
|
||||
if(found){
|
||||
printf("%d\n%d\n",i,j);
|
||||
while(!deq.empty()){
|
||||
putchar(deq.front());
|
||||
deq.pop_front();
|
||||
}
|
||||
puts("");
|
||||
break;
|
||||
}
|
||||
}
|
||||
if(found)break;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,75 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
#include<queue>
|
||||
using namespace std;
|
||||
#define inf 999999999
|
||||
struct node
|
||||
{
|
||||
int x,y,time;
|
||||
friend bool operator<(node a,node b)
|
||||
{
|
||||
return a.time>b.time;
|
||||
}
|
||||
};
|
||||
char map[1010][1010];
|
||||
int visit[1010][1010];
|
||||
int dir[4][2]={1,0,0,1,-1,0,0,-1};
|
||||
int n,m;
|
||||
int judge(int x,int y)
|
||||
{
|
||||
if(x>=1&&x<=n&&y>=1&&y<=m)
|
||||
return 1;
|
||||
return 0;
|
||||
}
|
||||
int bfs(int sx,int sy,int dx,int dy)
|
||||
{
|
||||
priority_queue<node>q;
|
||||
node in,out;
|
||||
int i;
|
||||
visit[sx][sy]=0;
|
||||
in.x=sx;
|
||||
in.y=sy;
|
||||
in.time=0;
|
||||
q.push(in);
|
||||
while(!q.empty())
|
||||
{
|
||||
in=q.top();
|
||||
q.pop();
|
||||
if(in.x==dx&&in.y==dy)
|
||||
return in.time;
|
||||
for(i=0;i<4;i++)
|
||||
{
|
||||
out.x=in.x+dir[i][0];
|
||||
out.y=in.y+dir[i][1];
|
||||
if(judge(out.x,out.y))
|
||||
{
|
||||
if(map[out.x][out.y]=='X')
|
||||
out.time=in.time;
|
||||
else
|
||||
out.time=in.time+1;
|
||||
if(visit[out.x][out.y]>out.time)
|
||||
{
|
||||
visit[out.x][out.y]=out.time;
|
||||
q.push(out);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int x0,y0,x1,y1,i,j,ans;
|
||||
while(scanf("%d%d",&n,&m),n+m)
|
||||
{
|
||||
for(i=1;i<=n;i++)
|
||||
scanf("%s",map[i]+1);
|
||||
for(i=1;i<=n;i++)
|
||||
for(j=1;j<=m;j++)
|
||||
visit[i][j]=inf;
|
||||
scanf("%d%d%d%d",&x0,&y0,&x1,&y1);
|
||||
ans=bfs(x0,y0,x1,y1);
|
||||
printf("%d\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,274 @@
|
|||
#include<iostream>
|
||||
#include<cmath>
|
||||
#include<cstdio>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
const int maxn = 50100;
|
||||
const double eps = 1e-8;
|
||||
const double pi = acos( -1.0 );
|
||||
const double inf = 1e100;
|
||||
#define _sign(x) ((x)>eps?1:((x<-eps)?2:0))
|
||||
int D( double x ) { return ( x < -eps ? -1 : x > eps ); }
|
||||
struct point {
|
||||
double x, y;
|
||||
point( double _x = 0, double _y = 0 ) : x( _x ), y( _y ) { }
|
||||
void input( ) { scanf( "%lf%lf", &x, &y ); }
|
||||
bool operator < (const point a)const
|
||||
{
|
||||
if(y==a.y)
|
||||
return x<a.x;
|
||||
return y<a.y;
|
||||
}
|
||||
};
|
||||
typedef struct line
|
||||
{
|
||||
point a,b;
|
||||
}Line;
|
||||
point operator + ( const point & a, const point & b ) {
|
||||
return point( a.x + b.x, a.y + b.y );
|
||||
}
|
||||
point operator - ( const point & a, const point & b ) {
|
||||
return point( a.x - b.x, a.y - b.y );
|
||||
}
|
||||
point operator * ( const point & a, const double scale ) {
|
||||
return point( a.x * scale, a.y * scale );
|
||||
}
|
||||
point operator / ( const point & a, const double scale ) {
|
||||
return point( a.x / scale, a.y / scale );
|
||||
}
|
||||
double operator ^ ( const point & a, const point & b ) {
|
||||
return ( a.x * b.y - a.y * b.x );
|
||||
}
|
||||
double operator & ( const point & a, const point & b ) {
|
||||
return ( a.x * b.x + a.y * b.y );
|
||||
}
|
||||
double dis2( const point & a, const point & b ) {
|
||||
point p = a - b;
|
||||
return ( p.x * p.x + p.y * p.y );
|
||||
}
|
||||
double dis( const point & a, const point & b ) {
|
||||
return sqrt( dis2( a, b ) );
|
||||
}
|
||||
double displ( const point & a, const point & b, const point & p ) {
|
||||
if( D( b - a & p - a ) > 0 && D( a - b & p - b ) > 0 ) {
|
||||
return fabs( a - p ^ b - p ) / dis( a, b );
|
||||
}
|
||||
return min( dis( p, a ), dis( p, b ) );
|
||||
}
|
||||
double disll( const point & a, const point &b, const point &c, const point &d ) {
|
||||
return min( min( displ( a, b, c ), displ( a, b, d ) ),
|
||||
min( displ( c, d, a ), displ( c, d, b ) ) );
|
||||
}
|
||||
double det(double x1,double y1,double x2,double y2)
|
||||
{
|
||||
return x1*y2-x2*y1;
|
||||
}
|
||||
double cross (const point & a, const point &b, const point &c)
|
||||
{
|
||||
return det(b.x-a.x,b.y-a.y,c.x-a.x,c.y-a.y);
|
||||
}
|
||||
point a[maxn],np[maxn];
|
||||
struct poly {
|
||||
int n;
|
||||
point p[ maxn ];
|
||||
void in( ) {
|
||||
for( int i = 0; i < n; i++ ) {
|
||||
p[ i ].x=np[i].x;
|
||||
p[i].y=np[i].y;
|
||||
}
|
||||
if( get_area( ) < 0 ) {
|
||||
reverse( p, p + n );
|
||||
}
|
||||
}
|
||||
double get_area( ) const {
|
||||
double area = 0;
|
||||
for( int i = 0; i < n; i++ ) {
|
||||
area += ( p[ i ] ^ p[ ( i + 1 ) % n ] );
|
||||
}
|
||||
return area;
|
||||
}
|
||||
};
|
||||
void solve( const poly & g1, const poly & g2 ) {
|
||||
int f[ 2 ] = { 0, 0 };
|
||||
point p0, p1, p2, p3;
|
||||
for( int i = 0; i < g1.n; i++ ) {
|
||||
if( g1.p[ i ].y < g1.p[ f[ 0 ] ].y ) {
|
||||
f[ 0 ] = i;
|
||||
}
|
||||
}
|
||||
for( int i = 0; i < g2.n; i++ ) {
|
||||
if( g2.p[ i ].y > g2.p[ f[ 1 ] ].y ) {
|
||||
f[ 1 ] = i;
|
||||
}
|
||||
}
|
||||
int cnt = 0;
|
||||
double best = inf;
|
||||
while( cnt < g1.n ) {
|
||||
p0 = g1.p[ f[ 0 ] ], p1 = g1.p[ ( f[ 0 ] + 1 ) % g1.n ];
|
||||
p2 = g2.p[ f[ 1 ] ], p3 = g2.p[ ( f[ 1 ] + 1 ) % g2.n ];
|
||||
int tmp = D( p1 - p0 ^ p3 - p2 );
|
||||
if( tmp == 0 ) {
|
||||
cnt++;
|
||||
f[ 0 ] = ( f[ 0 ] + 1 ) % g1.n;
|
||||
f[ 1 ] = ( f[ 1 ] + 1 ) % g2.n;
|
||||
best = min( best, disll( p0, p1, p2, p3 ) );
|
||||
}
|
||||
else if( tmp < 0 ) {
|
||||
cnt++;
|
||||
f[ 0 ] = ( f[ 0 ] + 1 ) % g1.n;
|
||||
best = min( best, displ( p0, p1, p2 ) );
|
||||
}
|
||||
else {
|
||||
f[ 1 ] = ( f[ 1 ] + 1 ) % g2.n;
|
||||
best = min( best, displ( p2, p3, p0 ) );
|
||||
}
|
||||
}
|
||||
printf( "%.4lf\n", best );
|
||||
}
|
||||
int covex_hull(int n)
|
||||
{
|
||||
int sz;
|
||||
sort(a,a+n);
|
||||
np[0]=a[0];
|
||||
np[1]=a[1];
|
||||
sz=1;
|
||||
for(int i=2;i<n;i++)
|
||||
{
|
||||
while(sz>0 && cross(np[sz],a[i],np[sz-1])<=0){
|
||||
sz--; }
|
||||
np[++sz]=a[i];
|
||||
}
|
||||
int temp=sz;
|
||||
for(int i=n-2;i>=0;i--)
|
||||
{
|
||||
while(sz>temp && cross(np[sz],a[i],np[sz-1])<=0) {
|
||||
sz--; }
|
||||
np[++sz]=a[i];
|
||||
}
|
||||
return sz;
|
||||
}
|
||||
bool pequal(const point & a,const point & b)
|
||||
{
|
||||
if(D(a.x-b.x)==0&&D(a.y-b.y)==0)return 1;
|
||||
else return 0;
|
||||
}
|
||||
int intersect(Line a,Line b)
|
||||
{
|
||||
if(D(cross(a.a,b.a,a.b)*cross(a.a,a.b,b.b))>0)return 1;
|
||||
else return 0;
|
||||
}
|
||||
int dotsOnSeg(const point & p,Line l)
|
||||
{
|
||||
if(pequal(l.a,l.b)){if(pequal(p,l.a))return 1 ;else return 0;}
|
||||
if(D(cross(p,l.a,l.b))==0&&(l.a.x-p.x)*(l.b.x-p.x)<=eps&&(l.a.y-p.y)*(l.b.y-p.y)<=eps)return 1;
|
||||
else return 0;
|
||||
}
|
||||
int intersectSegToSeg(Line a,Line b)
|
||||
{
|
||||
if(dotsOnSeg(a.a,b)||dotsOnSeg(a.b,b)||dotsOnSeg(b.a,a)||dotsOnSeg(b.b,a))return 1;
|
||||
if(intersect(a,b)&&intersect(b,a))return 1;
|
||||
else return 0;
|
||||
}
|
||||
int inside_convex(const point &q,int n,const point *p)
|
||||
{
|
||||
int i,s[3]={1,1,1};
|
||||
for(i=0;i<n&&s[1]|s[2];i++)
|
||||
{
|
||||
s[_sign(cross(p[i],p[(i+1)%n],q))]=0;
|
||||
}
|
||||
return s[1]|s[2];
|
||||
}
|
||||
poly g1, g2;
|
||||
int convex_intersect()
|
||||
{
|
||||
int flag=0;
|
||||
Line l1,l2;
|
||||
for(int i=1;i<=g1.n&&!flag;i++)
|
||||
{
|
||||
l1.a=g1.p[i-1];
|
||||
l1.b=g1.p[i%g1.n];
|
||||
for(int j=1;j<=g2.n;j++)
|
||||
{
|
||||
l2.a=g2.p[j-1];
|
||||
l2.b=g2.p[j%g2.n];
|
||||
if(intersectSegToSeg(l1,l2)){flag=1;break;}
|
||||
}
|
||||
}
|
||||
for(int i=0;i<g1.n&&g2.n>=3;i++)
|
||||
{
|
||||
if(inside_convex(g1.p[i],g2.n,g2.p)){flag=1;break;}
|
||||
}
|
||||
if(!flag)for(int i=0;i<g2.n&&g1.n>=3;i++)
|
||||
{
|
||||
if(inside_convex(g2.p[i],g1.n,g1.p)){flag=1;break;}
|
||||
}
|
||||
return flag;
|
||||
}
|
||||
int main( ) {
|
||||
int n,m;
|
||||
while(cin>>n>>m){
|
||||
for(int i=0;i<n;i++)
|
||||
{
|
||||
a[i].input();
|
||||
}
|
||||
g1.n=covex_hull(n);
|
||||
g1.in( );
|
||||
for(int i=0;i<m;i++)
|
||||
{
|
||||
a[i].input();
|
||||
}
|
||||
g2.n=covex_hull(m);
|
||||
g2.in( );
|
||||
if(g1.n==1&&g2.n==1)
|
||||
{
|
||||
double ans=dis(g2.p[0],g1.p[0]);
|
||||
printf("%.4lf\n",ans);
|
||||
continue ;
|
||||
}
|
||||
if(!convex_intersect()){
|
||||
if(g1.n==1&&g2.n>1)
|
||||
{
|
||||
double ans=inf;
|
||||
for(int i=1;i<=g2.n;i++)
|
||||
{
|
||||
ans=min(ans,displ(g2.p[i-1],g2.p[i%g2.n],g1.p[0]));
|
||||
}
|
||||
printf("%.4lf\n",ans);
|
||||
continue ;
|
||||
}
|
||||
if(g2.n==1&&g1.n>1)
|
||||
{
|
||||
double ans=inf;
|
||||
for(int i=1;i<=g1.n;i++)
|
||||
{
|
||||
ans=min(ans,displ(g1.p[i-1],g1.p[i%g1.n],g2.p[0]));
|
||||
}
|
||||
printf("%.4lf\n",ans);
|
||||
continue ;
|
||||
}
|
||||
if(g2.n==2&&g1.n>1)
|
||||
{
|
||||
double ans=inf;
|
||||
for(int i=1;i<=g1.n;i++)
|
||||
{
|
||||
ans=min(ans,disll(g1.p[i-1],g1.p[i%g1.n],g2.p[0],g2.p[1]));
|
||||
}
|
||||
printf("%.4lf\n",ans);
|
||||
continue ;
|
||||
}
|
||||
if(g1.n==2&&g2.n>1)
|
||||
{
|
||||
double ans=inf;
|
||||
for(int i=1;i<=g2.n;i++)
|
||||
{
|
||||
ans=min(ans,disll(g2.p[i-1],g2.p[i%g1.n],g1.p[0],g1.p[1]));
|
||||
}
|
||||
printf("%.4lf\n",ans);
|
||||
continue ;
|
||||
}
|
||||
solve( g1, g2 );
|
||||
}
|
||||
else printf("%.4lf\n",0);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,25 @@
|
|||
#include<iostream>
|
||||
#include<cstring>
|
||||
using namespace std;
|
||||
const int MAX=3000004;
|
||||
long long e[MAX];
|
||||
void euler()
|
||||
{
|
||||
e[1]=0;
|
||||
for(int i=2;i<MAX;++i)
|
||||
e[i]=i;
|
||||
for(int i=2;i<MAX;++i)
|
||||
if(e[i]==i)
|
||||
for(int j=i;j<MAX;j+=i)
|
||||
e[j]=e[j]/i*(i-1);
|
||||
for(int i=2;i<MAX;++i)
|
||||
e[i]+=e[i-1];
|
||||
}
|
||||
int main()
|
||||
{
|
||||
euler();
|
||||
int a,b;
|
||||
while(cin>>a>>b)
|
||||
cout<<e[b]-e[a-1]<<endl;
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,118 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
#include <queue>
|
||||
#include <vector>
|
||||
using namespace std;
|
||||
const int mod = 20090717;
|
||||
const int maxn = 103;
|
||||
const int max_num = 26;
|
||||
int idx[256];
|
||||
int n, m, x;
|
||||
int dp[26][103][1026];
|
||||
bool vis[26][103][1026];
|
||||
int cnt[1025];
|
||||
struct node {
|
||||
int v, p, zt;
|
||||
node(){}
|
||||
node(int v, int p, int zt) : v(v), p(p), zt(zt){}
|
||||
}Q[1000006];
|
||||
struct AcAuto {
|
||||
int val[maxn], f[maxn];
|
||||
int ch[maxn][max_num], tot;
|
||||
void init() {
|
||||
tot = 0;
|
||||
new_node();
|
||||
int i;
|
||||
for(i = 0; i < 26; i++)
|
||||
idx['a'+i] = i;
|
||||
}
|
||||
inline int new_node() {
|
||||
memset(ch[tot], 0, sizeof(ch[tot]));
|
||||
val[tot] = 0;
|
||||
f[tot] = 0;
|
||||
return tot++;
|
||||
}
|
||||
void insert(char *s, int id) {
|
||||
int i, j, p = 0;
|
||||
for(;*s; s++) {
|
||||
int k = idx[*s];
|
||||
if(!ch[p][k]) ch[p][k] = new_node();
|
||||
p = ch[p][k];
|
||||
}
|
||||
val[p] |= 1<<id;
|
||||
}
|
||||
void getfail() {
|
||||
int i, j, p = 0;
|
||||
int q[maxn];
|
||||
int *s = q, *e = q;
|
||||
for(i = 0; i < max_num; i++) if(ch[0][i]) *e++ = ch[0][i];
|
||||
while(s != e) {
|
||||
int u = *s++;
|
||||
for(i = 0; i < max_num; i++) {
|
||||
int &v = ch[u][i];
|
||||
if(!v) { v = ch[f[u]][i]; continue; }
|
||||
*e++ = v;
|
||||
j = f[u];
|
||||
while(j && !ch[j][i]) j = f[j];
|
||||
f[v] = ch[j][i];
|
||||
val[v] |= val[f[v]];
|
||||
}
|
||||
}
|
||||
}
|
||||
void solve() {
|
||||
int i, j, k, u;
|
||||
int M = (1<<m);
|
||||
for(i = 0; i <= n; i++)
|
||||
for(k = 0; k < tot; k++)
|
||||
for(j = 0; j < M; j++)
|
||||
dp[i][k][j] = 0;
|
||||
dp[0][0][0] = 1;
|
||||
node *s = Q, *e = Q;
|
||||
*e++ = node(0, 0, 0);
|
||||
vis[0][0][0] = 1;
|
||||
while(s != e) {
|
||||
node u = *s++;
|
||||
vis[u.v][u.p][u.zt] = 0;
|
||||
if(u.v >= n) continue;
|
||||
for(i = 0; i < max_num; i++) {
|
||||
int p = ch[u.p][i];
|
||||
node v = node(u.v+1, p, u.zt|val[p]);
|
||||
dp[v.v][v.p][v.zt] += dp[u.v][u.p][u.zt];
|
||||
if(dp[v.v][v.p][v.zt] >= mod) dp[v.v][v.p][v.zt] -= mod;
|
||||
if(!vis[v.v][v.p][v.zt]) {
|
||||
vis[v.v][v.p][v.zt] = 1;
|
||||
*e++ = v;
|
||||
}
|
||||
}
|
||||
}
|
||||
int ans = 0;
|
||||
for(i = 0; i < M; i++) {
|
||||
if(cnt[i] >= x)
|
||||
for(j = 0; j < tot; j++) {
|
||||
ans += dp[n][j][i];
|
||||
if(ans >= mod) ans -= mod;
|
||||
}
|
||||
}
|
||||
printf("%d\n", ans);
|
||||
}
|
||||
}AC;
|
||||
char str[13];
|
||||
int main() {
|
||||
int i, j;
|
||||
for(i = 0; i < 1024; i++) {
|
||||
int c = 0;
|
||||
for(j = i; j; j -= (j&-j)) c++;
|
||||
cnt[i] = c;
|
||||
}
|
||||
while( ~scanf("%d%d%d", &n, &m, &x) && (n || m || x)) {
|
||||
AC.init();
|
||||
for(i = 0; i < m; i++) {
|
||||
scanf("%s", str);
|
||||
AC.insert(str, i);
|
||||
}
|
||||
AC.getfail();
|
||||
AC.solve();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,88 @@
|
|||
#include <iostream>
|
||||
#include <string>
|
||||
#include<algorithm>
|
||||
#include <cstdio>
|
||||
#include<cmath>
|
||||
using namespace std;
|
||||
const double eps = 1e-8;
|
||||
int dcmp(double x)
|
||||
{
|
||||
if( fabs(x)<eps)
|
||||
return 0;
|
||||
return x < 0 ? -1:1;
|
||||
}
|
||||
struct pnode
|
||||
{
|
||||
double x,y;
|
||||
pnode(double x =0.0,double y=0.0):x(x),y(y){}
|
||||
int pread()
|
||||
{
|
||||
return scanf("%lf %lf",&x,&y);
|
||||
}
|
||||
pnode operator - (const pnode &b)const{ return pnode(x-b.x,y-b.y);}
|
||||
bool operator < (const pnode&b)const
|
||||
{
|
||||
return dcmp(x-b.x) <0 || (dcmp(x-b.x)== 0 && dcmp(y-b.y)<0);
|
||||
}
|
||||
double operator ^(const pnode&b)const
|
||||
{
|
||||
return x*b.y - y *b.x;
|
||||
}
|
||||
};
|
||||
typedef pnode myvec;
|
||||
myvec a,b,c,d;
|
||||
pnode pa[305],pb[305];
|
||||
double cross( pnode p0,pnode p1,pnode p2)
|
||||
{
|
||||
return (p1-p0) ^ (p2-p0);
|
||||
}
|
||||
double polygon_area(pnode*p,int n)
|
||||
{
|
||||
double area = 0.0;
|
||||
for( int i = 1;i < n-1 ;++i )
|
||||
area += cross( p[0], p[i], p[i+1]);
|
||||
return area*0.5;
|
||||
}
|
||||
double dot(myvec v)
|
||||
{
|
||||
return v.x*v.x + v.y *v.y;
|
||||
}
|
||||
void getpnode(int n,pnode *p,myvec &v,myvec &w)
|
||||
{
|
||||
p[0].pread();
|
||||
p[1].pread();
|
||||
myvec tmp = p[1] - p[0];
|
||||
v = w = tmp;
|
||||
for( int i = 2; i < n ;++i )
|
||||
{
|
||||
p[i].pread();
|
||||
v = p[i] - p[i-1];
|
||||
if( dcmp(dot(tmp)-dot(v))<0 )
|
||||
v = tmp;
|
||||
if( dcmp( dot(tmp)-dot(v)) > 0 )
|
||||
w = tmp;
|
||||
}
|
||||
tmp = p[n-1] - p[0];
|
||||
if( dcmp(dot(tmp)-dot(v))<0 )
|
||||
v = tmp;//v 涓哄澶杈瑰舰杈
|
||||
if( dcmp( dot(tmp)-dot(v)) > 0 )
|
||||
w = tmp;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int n;
|
||||
while( ~scanf("%d\n",&n))
|
||||
{
|
||||
getpnode(n,pa,a,c);
|
||||
getpnode(n,pb,b,d);
|
||||
double aarea = polygon_area(pa,n);
|
||||
double barea = polygon_area(pb,n);
|
||||
double k1 = sqrt(dot(a))/sqrt(dot(b));
|
||||
double k2 = sqrt( dot(c)) /sqrt(dot(d));
|
||||
if( dcmp(aarea - barea*k1*k1)==0 && dcmp(aarea - barea *k2*k2)==0 && dcmp(k1-k2)==0)
|
||||
puts("Yes");
|
||||
else
|
||||
puts("No");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,140 @@
|
|||
#include<cstdio>
|
||||
#include<iostream>
|
||||
#include<algorithm>
|
||||
#include<cstring>
|
||||
#include<string>
|
||||
#define LL long long
|
||||
using namespace std;
|
||||
LL n,m,A[105][105],p[10000],pos,d[105],r[105],len,B[105][105];
|
||||
bool vd[10005]={0};
|
||||
void prime()
|
||||
{
|
||||
pos=0;
|
||||
for(int i=2;i<10005;i++)
|
||||
{
|
||||
if(!vd[i])
|
||||
{
|
||||
if(i>1000) p[pos++]=i;
|
||||
for(int j=(i<<1);j<10005;j+=i)
|
||||
vd[i]=1;
|
||||
}
|
||||
}
|
||||
}
|
||||
void deal(LL k)
|
||||
{
|
||||
len=0;
|
||||
for(int i=0;i<pos&&k!=1;i++)
|
||||
{
|
||||
if(k%p[i]==0)
|
||||
{
|
||||
while(k%p[i]==0)
|
||||
{
|
||||
d[len++]=p[i];
|
||||
k/=p[i];
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
LL exp(LL a,LL b,LL mod)
|
||||
{
|
||||
LL ans=1;
|
||||
while(b)
|
||||
{
|
||||
if(b&1)ans=ans*a%mod;
|
||||
a=a*a%mod;b>>=1;
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
void ex_gcd(LL a,LL b,LL &dd,LL &x,LL &y)
|
||||
{
|
||||
if(b==0)
|
||||
x=1,y=0,dd=a;
|
||||
else
|
||||
{
|
||||
ex_gcd(b,a%b,dd,y,x);
|
||||
y-=x*(a/b);
|
||||
}
|
||||
}
|
||||
LL gauss(LL mod)
|
||||
{
|
||||
bool flag=0;
|
||||
LL ans=1;
|
||||
for(int i=0;i<n;i++)
|
||||
for(int j=0;j<n;j++)
|
||||
B[i][j]=A[i][j];
|
||||
for(int k=0;k<n-1;k++)
|
||||
{
|
||||
LL max_b=B[k][k];int bin=k;
|
||||
for(int i=k+1;i<n;i++)
|
||||
if(B[i][k]>max_b)
|
||||
max_b=B[i][k],bin=i;
|
||||
if(bin!=k)
|
||||
{
|
||||
for(int i=k;i<n;i++)
|
||||
swap(B[bin][i],B[k][i]);
|
||||
flag^=1;
|
||||
}
|
||||
if(B[k][k]<0)B[k][k]+=mod;
|
||||
LL Ni,y,dd;
|
||||
ex_gcd(B[k][k],mod,dd,Ni,y);
|
||||
Ni%=mod;
|
||||
if(Ni<0)Ni+=mod;
|
||||
for(int j=k+1;j<n;j++)
|
||||
{
|
||||
B[k][j]=B[k][j]*Ni%mod;
|
||||
if(B[k][j]<0)B[k][j]+=mod;
|
||||
for(int i=k+1;i<n;i++)
|
||||
{
|
||||
B[i][j]=(B[i][j]-(B[k][j]*B[i][k])%mod)%mod;
|
||||
if(B[i][j]<0)B[i][j]+=mod;
|
||||
}
|
||||
}
|
||||
ans*=B[k][k];
|
||||
ans%=mod;
|
||||
if(ans<0)ans+=mod;
|
||||
}
|
||||
ans*=B[n-1][n-1];
|
||||
ans%=mod;
|
||||
if(flag)ans=-ans;
|
||||
if(ans<0)ans+=mod;
|
||||
return ans;
|
||||
}
|
||||
LL china_remain()
|
||||
{
|
||||
LL a,b,c,c1,c2,x,y,dd,N;
|
||||
a=d[0],c1=r[0];
|
||||
if(c1==0)c1=d[0];
|
||||
for(int i=1;i<len;i++)
|
||||
{
|
||||
b=d[i],c2=r[i];
|
||||
ex_gcd(a,b,dd,x,y);
|
||||
c=c2-c1;
|
||||
LL b1=b/dd;
|
||||
x=((c/dd*x)%b1+b1)%b1;
|
||||
c1=a*x+c1;
|
||||
a=a*b1;
|
||||
}
|
||||
return c1%m;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
prime();
|
||||
while(cin>>n>>m)
|
||||
{
|
||||
deal(m);
|
||||
for(int i=0;i<n;i++)
|
||||
for(int j=0;j<n;j++)
|
||||
cin>>A[i][j];
|
||||
if(m==1)
|
||||
{
|
||||
cout<<0<<endl;
|
||||
continue;
|
||||
}
|
||||
for(int i=0;i<len;i++)
|
||||
{
|
||||
r[i]=gauss(d[i]);
|
||||
}
|
||||
cout<<china_remain()<<endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,126 @@
|
|||
#include <iostream>
|
||||
#include <cstring>
|
||||
#include <cstdio>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
const int maxn=1010,maxm=510;
|
||||
const int maxnode=maxn*maxm;
|
||||
const int INF=0x3f3f3f3f;
|
||||
int n,m;
|
||||
bool flag;
|
||||
struct DLX
|
||||
{
|
||||
int n,m,size;
|
||||
int U[maxnode],D[maxnode],R[maxnode],L[maxnode],Row[maxnode],Col[maxnode];
|
||||
int H[maxn],S[maxm];
|
||||
int ansd,ans[maxn];
|
||||
int LAMP[maxn];
|
||||
bool vis[maxn];
|
||||
void init(int _n,int _m)
|
||||
{
|
||||
n=_n; m=_m;
|
||||
for(int i=0;i<=m;i++)
|
||||
{
|
||||
S[i]=0; U[i]=D[i]=i;
|
||||
L[i]=i-1; R[i]=i+1;
|
||||
}
|
||||
R[m]=0; L[0]=m;
|
||||
size=m;
|
||||
for(int i=1;i<=n;i++)
|
||||
{
|
||||
vis[i]=false;
|
||||
LAMP[i]=0;
|
||||
H[i]=-1;
|
||||
}
|
||||
flag=false;
|
||||
}
|
||||
void Link(int r,int c)
|
||||
{
|
||||
++S[Col[++size]=c];
|
||||
Row[size]=r;
|
||||
D[size]=D[c];
|
||||
U[D[c]]=size;
|
||||
U[size]=c;
|
||||
D[c]=size;
|
||||
if(H[r]<0) H[r]=L[size]=R[size]=size;
|
||||
else
|
||||
{
|
||||
R[size]=R[H[r]];
|
||||
L[R[H[r]]]=size;
|
||||
L[size]=H[r];
|
||||
R[H[r]]=size;
|
||||
}
|
||||
}
|
||||
void remove(int c)
|
||||
{
|
||||
for(int i=D[c];i!=c;i=D[i])
|
||||
L[R[i]]=L[i],R[L[i]]=R[i];
|
||||
}
|
||||
void resume(int c)
|
||||
{
|
||||
for(int i=U[c];i!=c;i=U[i])
|
||||
L[R[i]]=R[L[i]]=i;
|
||||
}
|
||||
void Dance(int d)
|
||||
{
|
||||
if(flag) return ;
|
||||
if(R[0]==0)
|
||||
{
|
||||
for(int i=0;i<d;i++)
|
||||
{
|
||||
int lamp=(ans[i]+1)/2;
|
||||
if(ans[i]%2) LAMP[lamp]=1;
|
||||
}
|
||||
for(int i=1;i<=n/2;i++)
|
||||
{
|
||||
if(LAMP[i]==1) printf("ON");
|
||||
else printf("OFF");
|
||||
if(i!=n/2) putchar(32); else putchar(10);
|
||||
}
|
||||
flag=true;
|
||||
return ;
|
||||
}
|
||||
int c=R[0];
|
||||
for(int i=R[0];i!=0;i=R[i])
|
||||
{
|
||||
if(S[i]<S[c]) c=i;
|
||||
}
|
||||
for(int i=D[c];i!=c;i=D[i])
|
||||
{
|
||||
if(vis[Row[i]]) continue;
|
||||
int r1=Row[i],r2=Row[i];
|
||||
if(r1%2==0) r2--;else r2++;
|
||||
vis[r1]=true; vis[r2]=true;
|
||||
remove(i);
|
||||
for(int j=R[i];j!=i;j=R[j]) remove(j);
|
||||
ans[d]=Row[i];
|
||||
Dance(d+1);
|
||||
for(int j=L[i];j!=i;j=L[j]) resume(j);
|
||||
resume(i);
|
||||
vis[r1]=false; vis[r2]=false;
|
||||
}
|
||||
}
|
||||
};
|
||||
DLX dlx;
|
||||
int main()
|
||||
{
|
||||
while(scanf("%d%d",&n,&m)!=EOF)
|
||||
{
|
||||
dlx.init(2*m,n);
|
||||
for(int i=1;i<=n;i++)
|
||||
{
|
||||
int k;
|
||||
scanf("%d",&k);
|
||||
for(int j=0;j<k;j++)
|
||||
{
|
||||
int p; char sw[20];
|
||||
scanf("%d%s",&p,sw);
|
||||
if(sw[1]=='N') dlx.Link(2*p-1,i);
|
||||
else if(sw[1]=='F') dlx.Link(2*p,i);
|
||||
}
|
||||
}
|
||||
dlx.Dance(0);
|
||||
if(flag==false) puts("-1");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,75 @@
|
|||
#include<stdio.h>
|
||||
#include<iostream>
|
||||
#include<string.h>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
const int MAXN=1010;
|
||||
int a[MAXN];
|
||||
int sum[MAXN];
|
||||
int cost[MAXN];
|
||||
int q[MAXN];
|
||||
int head,tail;
|
||||
int n,m;
|
||||
int dp[MAXN][MAXN];
|
||||
int DP()
|
||||
{
|
||||
for(int i=1;i<=n;i++)
|
||||
{
|
||||
dp[i][0]=cost[i];
|
||||
dp[i][i-1]=0;
|
||||
}
|
||||
for(int j=1;j<=m;j++)
|
||||
{
|
||||
head=tail=0;
|
||||
q[tail++]=j;
|
||||
for(int i=j+1;i<=n;i++)
|
||||
{
|
||||
while(head+1<tail)
|
||||
{
|
||||
int p1=q[head];
|
||||
int p2=q[head+1];
|
||||
int x1=sum[p1];
|
||||
int x2=sum[p2];
|
||||
int y1=dp[p1][j-1]-cost[p1]+sum[p1]*sum[p1];
|
||||
int y2=dp[p2][j-1]-cost[p2]+sum[p2]*sum[p2];
|
||||
if((y2-y1)<=sum[i]*(x2-x1)) head++;
|
||||
else break;
|
||||
}
|
||||
int k=q[head];
|
||||
dp[i][j]=dp[k][j-1]+cost[i]-cost[k]-sum[k]*sum[i]+sum[k]*sum[k];
|
||||
while(head+1<tail)
|
||||
{
|
||||
int p1=q[tail-2];
|
||||
int p2=q[tail-1];
|
||||
int p3=i;
|
||||
int x1=sum[p1];
|
||||
int x2=sum[p2];
|
||||
int x3=sum[p3];
|
||||
int y1=dp[p1][j-1]-cost[p1]+sum[p1]*sum[p1];
|
||||
int y2=dp[p2][j-1]-cost[p2]+sum[p2]*sum[p2];
|
||||
int y3=dp[p3][j-1]-cost[p3]+sum[p3]*sum[p3];
|
||||
if((y2-y1)*(x3-x2)>=(y3-y2)*(x2-x1))tail--;
|
||||
else break;
|
||||
}
|
||||
q[tail++]=i;
|
||||
}
|
||||
}
|
||||
return dp[n][m];
|
||||
}
|
||||
int main()
|
||||
{
|
||||
while(scanf("%d%d",&n,&m)==2)
|
||||
{
|
||||
if(n==0&&m==0)break;
|
||||
sum[0]=0;
|
||||
cost[0]=0;
|
||||
for(int i=1;i<=n;i++)
|
||||
{
|
||||
scanf("%d",&a[i]);
|
||||
sum[i]=sum[i-1]+a[i];
|
||||
cost[i]=cost[i-1]+sum[i-1]*a[i];
|
||||
}
|
||||
printf("%d\n",DP());
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,45 @@
|
|||
#include <iostream>
|
||||
using namespace std;
|
||||
const int size = 1010;
|
||||
char str[size];
|
||||
int h[size];
|
||||
int cnt[size];
|
||||
int main()
|
||||
{
|
||||
cin.sync_with_stdio(false);
|
||||
int n , m , ans , sum , maxH , area;
|
||||
while( cin >> n >> m )
|
||||
{
|
||||
memset( cnt , 0 , sizeof(cnt) );
|
||||
memset( h , 0 , sizeof(h) );
|
||||
ans = 0;
|
||||
for( int i = 1 ; i<=n ; i++ )
|
||||
{
|
||||
maxH = sum = 0;
|
||||
cin >> str;
|
||||
for( int j = 0 ; str[j]!='\0' ; j++ )
|
||||
{
|
||||
if( str[j]=='1' )
|
||||
h[j+1] ++;
|
||||
else
|
||||
h[j+1] = 0;
|
||||
cnt[ h[j+1] ] ++;
|
||||
if( maxH < h[j+1] )
|
||||
maxH = h[j+1];
|
||||
}
|
||||
for( int k = 0 ; k<=maxH ; k++ )
|
||||
{
|
||||
if( cnt[k]!=0 )
|
||||
{
|
||||
area = k * (m-sum);
|
||||
sum += cnt[k];
|
||||
if( area>ans )
|
||||
ans = area;
|
||||
}
|
||||
cnt[k] = 0;
|
||||
}
|
||||
}
|
||||
cout << ans << endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,58 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
#include<stdlib.h>
|
||||
#define N 111
|
||||
int n,need;
|
||||
int V[N],D[N];
|
||||
int match[N],visit[N];
|
||||
struct Eage{
|
||||
int to,next;
|
||||
}eage[N*N];
|
||||
int tot,head[N];
|
||||
void add(int a,int b){
|
||||
eage[tot].to=b;eage[tot].next=head[a];head[a]=tot++;
|
||||
}
|
||||
int dfs(int k)
|
||||
{
|
||||
int j,v;
|
||||
for(j=head[k];j!=-1;j=eage[j].next)
|
||||
{
|
||||
v=eage[j].to;
|
||||
if(visit[v]) continue;
|
||||
visit[v]=1;
|
||||
if(k*need+D[v]>V[v]) continue;
|
||||
if(match[v]==-1 || dfs(match[v]))
|
||||
{
|
||||
match[v]=k;
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int i,l;
|
||||
int flag;
|
||||
while(scanf("%d%d",&n,&need)!=-1)
|
||||
{
|
||||
for(i=1;i<=n;i++) scanf("%d%d",&V[i],&D[i]);
|
||||
tot=0;
|
||||
memset(head,-1,sizeof(head));
|
||||
for(i=1;i<=n;i++)for(l=1;l<=n;l++)
|
||||
add(i,l);
|
||||
flag=0;
|
||||
memset(match,-1,sizeof(match));
|
||||
for(i=1;i<=n;i++)
|
||||
{
|
||||
memset(visit,0,sizeof(visit));
|
||||
if(!dfs(i)) {flag=1;break;}
|
||||
}
|
||||
if(flag) {printf("The zombies eat your brains!\n");continue;}
|
||||
for(i=1;i<=n;i++) if(match[i]==1) {printf("%d",i);break;}
|
||||
for(i=2;i<=n;i++)
|
||||
for(l=1;l<=n;l++)
|
||||
if(match[l]==i) {printf(" %d",l);break;}
|
||||
printf("\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
#include<stdlib.h>
|
||||
#include<math.h>
|
||||
#define N 111
|
||||
int ans[N];
|
||||
void init()
|
||||
{
|
||||
ans[5]=272400600;
|
||||
ans[6]=9717617;
|
||||
ans[7]=898515;
|
||||
int k,q;
|
||||
double t,temp;
|
||||
for(k=8;k<=100;k++)
|
||||
{
|
||||
t=0;
|
||||
temp=1;
|
||||
q=0;
|
||||
while(t<100)
|
||||
{
|
||||
t+=k/temp;
|
||||
temp++;
|
||||
q++;
|
||||
}
|
||||
ans[k]=q;
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
init();
|
||||
int k;
|
||||
while(scanf("%d",&k)!=-1)
|
||||
printf("%d\n",ans[k]);
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,65 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
#include<stdlib.h>
|
||||
#define N 311
|
||||
int num[N][N];
|
||||
int len[N][N];
|
||||
int main()
|
||||
{
|
||||
int n,m;
|
||||
int i,l,k,t;
|
||||
int s,e,dis;
|
||||
int a,b,c,d;
|
||||
while(scanf("%d%d",&n,&m),n||m)
|
||||
{
|
||||
memset(num,0,sizeof(num));
|
||||
for(i=1;i<=n;i++)
|
||||
{
|
||||
for(l=1;l<=n;l++)
|
||||
{
|
||||
if(i==l) len[i][l]=0;
|
||||
else len[i][l]=22222222;
|
||||
}
|
||||
}
|
||||
for(i=0;i<m;i++)
|
||||
{
|
||||
scanf("%d%d%d",&s,&e,&dis);
|
||||
if(len[s][e]<dis) continue;
|
||||
len[s][e]=len[e][s]=dis;
|
||||
num[s][e]=num[e][s]=1;
|
||||
}
|
||||
for(k=1;k<=n;k++)
|
||||
{
|
||||
for(i=1;i<=n;i++)
|
||||
{
|
||||
for(l=1;l<=n;l++)
|
||||
{
|
||||
t=len[i][k]+len[k][l];
|
||||
if(t>len[i][l]) continue;
|
||||
if(t<len[i][l])
|
||||
{
|
||||
len[i][l]=t;
|
||||
num[i][l]=num[i][k]+num[k][l];
|
||||
}
|
||||
else if(num[i][k]+num[k][l]>num[i][l])
|
||||
num[i][l]=num[i][k]+num[k][l];
|
||||
}
|
||||
}
|
||||
}
|
||||
scanf("%d%d%d%d",&a,&b,&c,&d);
|
||||
int ans=-1;
|
||||
for(i=1;i<=n;i++)
|
||||
{
|
||||
for(l=1;l<=n;l++)
|
||||
{
|
||||
if(num[i][l]>ans
|
||||
&& (len[a][b]==len[a][i]+len[i][l]+len[l][b])
|
||||
&& (len[c][d]==len[c][i]+len[i][l]+len[l][d])
|
||||
)
|
||||
ans=num[i][l];
|
||||
}
|
||||
}
|
||||
printf("%d\n",ans+1);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,99 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#define For(i, n) for(i=0; i<(n); i++)
|
||||
const int N = 64;
|
||||
double P[N][N];
|
||||
double A[N][N];
|
||||
int out[N];
|
||||
int t;
|
||||
double s[N];
|
||||
int n, m;
|
||||
double dp[N][N];
|
||||
double dpx[N][N];
|
||||
int pre[N][N];
|
||||
int ppt[N];
|
||||
void read()
|
||||
{
|
||||
int i, j;
|
||||
For(i, n)
|
||||
scanf("%lf", &s[i]);
|
||||
For(i, n)
|
||||
For(j, n)
|
||||
scanf("%lf", &P[i][j]);
|
||||
For(i, n)
|
||||
For(j, m)
|
||||
scanf("%lf", &A[i][j]);
|
||||
For(i, n)
|
||||
{
|
||||
s[i] /= 100;
|
||||
For(j, n)
|
||||
P[i][j] /= 100, A[i][j] /= 100;
|
||||
}
|
||||
scanf("%d", &t);
|
||||
For(i, t)
|
||||
scanf("%d", &out[i]);
|
||||
For(i, t)
|
||||
out[i] -= 1;
|
||||
}
|
||||
void doit()
|
||||
{
|
||||
memset(dpx, 0, sizeof(dpx));
|
||||
int i, j, k;
|
||||
double tmp;
|
||||
For(j, n)
|
||||
{
|
||||
dp[0][j] = s[j];
|
||||
dpx[0][j] = dp[0][j] * A[j][out[0]];
|
||||
}
|
||||
for (i = 1; i < t; i++)
|
||||
{
|
||||
For(j, n)
|
||||
{
|
||||
For(k, n)
|
||||
{
|
||||
tmp = dpx[i - 1][k] * P[k][j] * A[j][out[i]];
|
||||
if (tmp > dpx[i][j])
|
||||
{
|
||||
dpx[i][j] = tmp;
|
||||
dp[i][j] = dp[i - 1][k] * P[k][j];
|
||||
pre[i][j] = k;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
void pt()
|
||||
{
|
||||
int i;
|
||||
int tmp;
|
||||
double mx = 0;
|
||||
For(i, n)
|
||||
if (dpx[t - 1][i] > mx)
|
||||
{
|
||||
mx = dpx[t - 1][i];
|
||||
tmp = i;
|
||||
}
|
||||
ppt[t - 1] = tmp;
|
||||
for (i = n-1; i > 0; i--)
|
||||
{
|
||||
ppt[i - 1] = pre[i][tmp];
|
||||
tmp = ppt[i - 1];
|
||||
}
|
||||
For(i, t)
|
||||
{
|
||||
if (i)
|
||||
putchar(' ');
|
||||
printf("%d", ppt[i] + 1);
|
||||
}
|
||||
puts("");
|
||||
}
|
||||
int main()
|
||||
{
|
||||
while (2 == scanf("%d %d", &n, &m))
|
||||
{
|
||||
read();
|
||||
doit();
|
||||
pt();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,68 @@
|
|||
#include <iostream>
|
||||
#include <stdio.h>
|
||||
#include <algorithm>
|
||||
#include <math.h>
|
||||
#include <string.h>
|
||||
#include <set>
|
||||
#include <queue>
|
||||
using namespace std;
|
||||
typedef struct abcd
|
||||
{
|
||||
int p,last;
|
||||
} abcd;
|
||||
abcd a[110000];
|
||||
int flag[110000];
|
||||
int main()
|
||||
{
|
||||
int c,n,b,i,j,now,ans;
|
||||
while(~scanf("%d%d%d",&c,&n,&b))
|
||||
{
|
||||
for(i=0; i<n; i++)flag[i]=110000;
|
||||
for(i=0; i<b; i++)
|
||||
scanf("%d",&a[i].p);
|
||||
for(i=b-1; i>=0; i--)
|
||||
{
|
||||
a[i].last=flag[a[i].p];
|
||||
flag[a[i].p]=i;
|
||||
}
|
||||
ans=now=0;
|
||||
memset(flag,0,sizeof(flag));
|
||||
priority_queue<pair<int,int> > q;
|
||||
while(!q.empty())q.pop();
|
||||
for(i=0; i<b; i++)
|
||||
{
|
||||
if(now<c)
|
||||
{
|
||||
if(flag[a[i].p])
|
||||
{
|
||||
q.push(make_pair(a[i].last,a[i].p));
|
||||
}
|
||||
else
|
||||
{
|
||||
flag[a[i].p]=1;
|
||||
now++;
|
||||
ans++;
|
||||
q.push(make_pair(a[i].last,a[i].p));
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if(flag[a[i].p])
|
||||
{
|
||||
q.push(make_pair(a[i].last,a[i].p));
|
||||
}
|
||||
else
|
||||
{
|
||||
ans++;
|
||||
while(flag[q.top().second]==0)q.pop();
|
||||
pair<int,int >t=q.top();
|
||||
q.pop();
|
||||
flag[a[i].p]=1;
|
||||
flag[t.second]=0;
|
||||
q.push(make_pair(a[i].last,a[i].p));
|
||||
}
|
||||
}
|
||||
}
|
||||
cout<<ans<<endl;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,94 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
#include<stdlib.h>
|
||||
const int N=100111;
|
||||
const int Limit=9901;
|
||||
int n,h;
|
||||
int high[N],index[N],lowbit[N];
|
||||
int C[N];
|
||||
struct node{
|
||||
int index,high;
|
||||
}E[N];
|
||||
int cmp(const void *a,const void *b)
|
||||
{
|
||||
node *c,*d;
|
||||
c=(node *)a;
|
||||
d=(node *)b;
|
||||
return c->high-d->high;
|
||||
}
|
||||
void update(int k,int dir)
|
||||
{
|
||||
while(0<k && k<=n)
|
||||
{
|
||||
C[k]+=dir;
|
||||
C[k]%=Limit;
|
||||
k+=lowbit[k];
|
||||
}
|
||||
}
|
||||
int sum(int k)
|
||||
{
|
||||
int p=0;
|
||||
while(0<k && k<=n)
|
||||
{
|
||||
p+=C[k];
|
||||
p%=Limit;
|
||||
k-=lowbit[k];
|
||||
}
|
||||
return p;
|
||||
}
|
||||
int solve()
|
||||
{
|
||||
int i;
|
||||
int low,mid,up;
|
||||
int a,b,c,temp,x,z;
|
||||
int ans;
|
||||
memset(C,0,sizeof(C));
|
||||
E[0].high=-1111;
|
||||
qsort(E,n+1,sizeof(node),cmp);
|
||||
for(i=1;i<=n;i++) index[E[i].index]=i;
|
||||
for(i=1;i<=n;i++)
|
||||
{
|
||||
temp=high[i]-h;
|
||||
low=1;up=n;
|
||||
while(low<=up)
|
||||
{
|
||||
mid=(low+up)>>1;
|
||||
if(E[mid].high<temp) low=mid+1;
|
||||
else up=mid-1;
|
||||
}
|
||||
a=low;
|
||||
b=index[i];
|
||||
temp=high[i]+h;
|
||||
low=1;up=n;
|
||||
while(low<=up)
|
||||
{
|
||||
mid=(low+up)>>1;
|
||||
if(E[mid].high<=temp) low=mid+1;
|
||||
else up=mid-1;
|
||||
}
|
||||
c=low-1;
|
||||
if(a-1<=0) x=0;
|
||||
else x=sum(a-1);
|
||||
z=sum(c);
|
||||
update(b,z-x+1);
|
||||
}
|
||||
ans=sum(n)-n;
|
||||
while(ans<0) ans+=9901;
|
||||
return ans;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int i;
|
||||
for(i=1;i<=100000;i++) lowbit[i]=i&(-i);
|
||||
while(scanf("%d%d",&n,&h)!=-1)
|
||||
{
|
||||
for(i=1;i<=n;i++)
|
||||
{
|
||||
scanf("%d",&high[i]);
|
||||
E[i].index=i;
|
||||
E[i].high=high[i];
|
||||
}
|
||||
printf("%d\n",solve());
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,51 @@
|
|||
#include <cstdio>
|
||||
using namespace std;
|
||||
typedef long long LL;
|
||||
LL phi(LL x)
|
||||
{
|
||||
LL ans=x;
|
||||
for(LL i=2;i*i<=x;i++)
|
||||
if(x%i==0){
|
||||
ans=ans/i*(i-1);
|
||||
while(x%i==0) x/=i;
|
||||
}
|
||||
if(x>1)
|
||||
ans=ans/x*(x-1);
|
||||
return ans;
|
||||
}
|
||||
LL pow_mod(LL a,LL p,LL mod)
|
||||
{
|
||||
LL ans=1;
|
||||
while(p)
|
||||
{
|
||||
if(p&1)
|
||||
{
|
||||
ans=ans*a;
|
||||
if(ans>mod)
|
||||
ans=ans%mod+mod;
|
||||
}
|
||||
a=a*a;
|
||||
if(a>mod)
|
||||
a=a%mod+mod;
|
||||
p>>=1;
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
LL f(LL n,LL m)
|
||||
{
|
||||
if(n<10) return n;
|
||||
LL p=f(n/10,phi(m));
|
||||
return pow_mod(n%10,p,m);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int T;
|
||||
scanf("%d",&T);
|
||||
while(T--)
|
||||
{
|
||||
LL n,m;
|
||||
scanf("%I64d%I64d",&n,&m);
|
||||
printf("%I64d\n",f(n,m)%m);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,57 @@
|
|||
#include<iostream>
|
||||
#include<string.h>
|
||||
using namespace std;
|
||||
__int64 a[100005],c[100005],d[100005],n;
|
||||
int lowbit(int x)
|
||||
{
|
||||
return x&(-x);
|
||||
}
|
||||
__int64 sumc(int x)
|
||||
{
|
||||
__int64 s=0;
|
||||
while(x>0)
|
||||
{
|
||||
s+=c[x];
|
||||
x-=lowbit(x);
|
||||
}
|
||||
return s;
|
||||
}
|
||||
__int64 sumd(int x)
|
||||
{
|
||||
__int64 s=0;
|
||||
while(x>0)
|
||||
{
|
||||
s+=d[x];
|
||||
x-=lowbit(x);
|
||||
}
|
||||
return s;
|
||||
}
|
||||
void updata(int i,int j)
|
||||
{
|
||||
while(i<=n)
|
||||
{
|
||||
c[i]+=1;
|
||||
d[i]+=j;
|
||||
i+=lowbit(i);
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
while(scanf("%I64d",&n)>0)
|
||||
{
|
||||
memset(a,0,sizeof(a));
|
||||
memset(c,0,sizeof(c));
|
||||
memset(d,0,sizeof(d));
|
||||
__int64 s=0,count=0;
|
||||
for(int i=1;i<=n;i++)
|
||||
{
|
||||
scanf("%d",&a[i]);
|
||||
updata(a[i],a[i]);
|
||||
count+=a[i];
|
||||
s+=(i-sumc(a[i]))*a[i];
|
||||
s+=count-sumd(a[i]);
|
||||
}
|
||||
printf("%I64d\n",s);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,64 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<list>
|
||||
#include<algorithm>
|
||||
#include<cstring>
|
||||
#include<string>
|
||||
#include<stack>
|
||||
#include<map>
|
||||
#include<vector>
|
||||
#include<cmath>
|
||||
#include<memory.h>
|
||||
#include<set>
|
||||
#include<cctype>
|
||||
#define ll long long
|
||||
#define LL __int64
|
||||
#define eps 1e-8
|
||||
#define inf 0xfffffff
|
||||
using namespace std;
|
||||
typedef struct Node {
|
||||
char s[2000 + 10];
|
||||
};
|
||||
Node sasd[2000 + 10];
|
||||
int b,n;
|
||||
int num[2000 + 10];
|
||||
int tot;
|
||||
void clear() {
|
||||
memset(num,0,sizeof(num));
|
||||
tot = 0;
|
||||
}
|
||||
void dfs(int pos,int e) {
|
||||
if(pos == n) {
|
||||
if(n != 1 && num[pos - 1] == 0)return;
|
||||
for(int i=pos - 1;i>=0;i--) {
|
||||
if(num[i] >= 10)
|
||||
sasd[tot].s[n - i - 1] = 'A' + num[i] - 10;
|
||||
else
|
||||
sasd[tot].s[n - i - 1] = '0' + num[i];
|
||||
}
|
||||
sasd[tot++].s[n] = 0;
|
||||
return;
|
||||
}
|
||||
for(int i=0;i<b;i++) {
|
||||
num[pos] = i;
|
||||
int ans = 0;
|
||||
for(int j=0;j<=pos;j++)
|
||||
ans += num[j] * num[pos - j];
|
||||
if((ans + e)%b == i)
|
||||
dfs(pos + 1,(ans + e)/b);
|
||||
}
|
||||
}
|
||||
bool cmp(Node x,Node y) {
|
||||
return strcmp(x.s,y.s) < 0;
|
||||
}
|
||||
int main() {
|
||||
while(scanf("%d %d",&b,&n) == 2) {
|
||||
clear();
|
||||
dfs(0,0);
|
||||
sort(sasd,sasd + tot,cmp);
|
||||
printf("%d\n",tot);
|
||||
for(int i=0;i<tot;i++)
|
||||
printf("%s\n",sasd[i].s);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,41 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<cmath>
|
||||
#include<vector>
|
||||
#include<string>
|
||||
#include<algorithm>
|
||||
#include<queue>
|
||||
#define LL long long
|
||||
#define eps 1e-7
|
||||
using namespace std;
|
||||
int prime[100005][20];
|
||||
int cnt[100005]={0};
|
||||
void Init(){
|
||||
for(int i=2;i<=100000;i++){
|
||||
if(cnt[i]) continue;
|
||||
prime[i][0]=i;
|
||||
cnt[i]=1;
|
||||
for(int j=2;j*i<=100000;j++)
|
||||
prime[i*j][cnt[i*j]++]=i;
|
||||
}
|
||||
}
|
||||
LL dfs(int m,int n,int idx){
|
||||
LL ret=0;
|
||||
for(int i=idx;i<cnt[m];i++)
|
||||
ret+=n/prime[m][i]-dfs(m,n/prime[m][i],i+1);
|
||||
return ret;
|
||||
}
|
||||
int main(){
|
||||
Init();
|
||||
int t,n,m;
|
||||
scanf("%d",&t);
|
||||
while(t--){
|
||||
scanf("%d%d",&n,&m);
|
||||
LL ans=n;
|
||||
for(int i=2;i<=m;i++)
|
||||
ans+=n-dfs(i,n,0);
|
||||
printf("%I64d\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,78 @@
|
|||
#include <iostream>
|
||||
#include <string.h>
|
||||
using namespace std;
|
||||
#define N 3
|
||||
#define ll __int64
|
||||
#define MOD 200907
|
||||
struct Mat
|
||||
{
|
||||
ll martix[N][N];
|
||||
};
|
||||
Mat res,q,tp,tp1,tp2,tp3;
|
||||
void er_fun(int x)
|
||||
{
|
||||
int i,j,k,flag=0;
|
||||
tp1=q;
|
||||
tp=res;
|
||||
while (x)
|
||||
{
|
||||
if(x&1)
|
||||
{
|
||||
flag=1;
|
||||
memset(tp2.martix,0,sizeof(tp2.martix));
|
||||
for (i=0;i<N;i++)
|
||||
{
|
||||
for (j=0;j<N;j++)
|
||||
{
|
||||
for(k=0;k<N;k++)
|
||||
{
|
||||
tp2.martix[i][j]+=(tp.martix[i][k]*tp1.martix[k][j])%MOD;
|
||||
tp2.martix[i][j]%=MOD;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
memset(tp3.martix,0,sizeof(tp3.martix));
|
||||
for (i=0;i<N;i++)
|
||||
{
|
||||
for (j=0;j<N;j++)
|
||||
{
|
||||
for(k=0;k<N;k++)
|
||||
{
|
||||
tp3.martix[i][j]+=(tp1.martix[i][k]*tp1.martix[k][j])%MOD;
|
||||
}
|
||||
}
|
||||
}
|
||||
if(flag)
|
||||
tp=tp2;
|
||||
tp1=tp3;
|
||||
x>>=1;
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int i,j;
|
||||
ll n,sum;
|
||||
for (i=0;i<N;i++)
|
||||
{
|
||||
for (j=0;j<N;j++)
|
||||
{
|
||||
res.martix[i][j]=(i==j);
|
||||
}
|
||||
}
|
||||
q.martix[0][0]=q.martix[1][0]=q.martix[0][2]=q.martix[2][2]=1;
|
||||
q.martix[1][1]=q.martix[1][2]=q.martix[2][0]=q.martix[2][1]=0;
|
||||
q.martix[0][1]=2;
|
||||
while (scanf("%I64d",&n),n)
|
||||
{
|
||||
if(n==1 || n==2)
|
||||
{
|
||||
printf("%I64d\n",n);
|
||||
continue;
|
||||
}
|
||||
er_fun(n-2);
|
||||
sum=(tp.martix[0][0]*2+tp.martix[0][1]+tp.martix[0][2])%MOD;
|
||||
printf("%I64d\n",sum);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,18 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
int gcd(int a, int b)
|
||||
{
|
||||
return b == 0 ? a : gcd(b, a % b);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int n,m,c;
|
||||
while(scanf("%d%d",&n,&m)!=EOF)
|
||||
{
|
||||
if(n==0&&m==0)break;
|
||||
n+=2;m+=1;
|
||||
c=gcd(n,m);
|
||||
printf("%d %d\n",m/c,n/c);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,51 @@
|
|||
#include<cstdio>
|
||||
#include<iostream>
|
||||
#include<cstring>
|
||||
using namespace std;
|
||||
int v[105],num[105];
|
||||
int dp[100010];
|
||||
int main()
|
||||
{
|
||||
int i,j,k,n,m,tmp,sum;
|
||||
while(cin>>n>>m,(m+n))
|
||||
{
|
||||
sum=0;
|
||||
memset(dp,0,sizeof(dp));
|
||||
dp[0]=1;
|
||||
for(i=1;i<=n;i++)
|
||||
{
|
||||
cin>>v[i];
|
||||
}
|
||||
for(i=1;i<=n;i++)
|
||||
{
|
||||
cin>>num[i];
|
||||
}
|
||||
for(i=1;i<=n;i++)
|
||||
{
|
||||
tmp=num[i];
|
||||
for(j=1;j<=tmp;j*=2)
|
||||
{
|
||||
for(k=m;k>=j*v[i];k--)
|
||||
{
|
||||
dp[k]+=dp[k-j*v[i]];
|
||||
}
|
||||
tmp-=j;
|
||||
}
|
||||
if(tmp)
|
||||
{
|
||||
for(k=m;k>=tmp*v[i];k--)
|
||||
{
|
||||
dp[k]+=dp[k-tmp*v[i]];
|
||||
}
|
||||
}
|
||||
}
|
||||
for(j=1;j<=m;j++)
|
||||
{
|
||||
if(dp[j])
|
||||
{
|
||||
sum++;
|
||||
}
|
||||
}
|
||||
cout<<sum<<endl;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,16 @@
|
|||
#include <cstdio>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
int const N = 200010;
|
||||
int m, n, c[N], l, dp[N], i, j;
|
||||
int main() {
|
||||
while(~scanf("%d%d", &m, &n)) {
|
||||
for(j=1; j<=m; c[j++]=dp[n])
|
||||
for(i=2, scanf("%d", &dp[1]); i<=n && scanf("%d", &l); i++)
|
||||
dp[i] = max(dp[i-2]+l, dp[i-1]);
|
||||
for(i=2, dp[1]=c[1]; i<=m; i++)
|
||||
dp[i] = max(dp[i-2]+c[i], dp[i-1]);
|
||||
printf("%d\n", dp[m]);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,67 @@
|
|||
#include <string>
|
||||
#include <cstring>
|
||||
#include <cstdlib>
|
||||
#include <iostream>
|
||||
using namespace std;
|
||||
struct node
|
||||
{
|
||||
int id;
|
||||
int cnt;
|
||||
int al[26];
|
||||
};
|
||||
int ptr=0;
|
||||
node word[1000000];
|
||||
void Init(int z)
|
||||
{
|
||||
for(int i=0;i<26;i++)
|
||||
word[z].al[i]=-1;
|
||||
}
|
||||
void Insert(char*s,int len,int x)
|
||||
{
|
||||
int now=0;
|
||||
for(int i=0;i<len;i++)
|
||||
{
|
||||
if(word[now].al[s[i]-'a']==-1)
|
||||
{
|
||||
word[now].al[s[i]-'a']=++ptr;
|
||||
Init(ptr); now=ptr;
|
||||
}
|
||||
else now=word[now].al[s[i]-'a'];
|
||||
if(word[now].id!=x) word[now].cnt++;
|
||||
//cout<<now<<endl;
|
||||
word[now].id=x;
|
||||
}
|
||||
}
|
||||
int find(char*s)
|
||||
{
|
||||
int now=0;
|
||||
int len=strlen(s);
|
||||
for(int i=0;i<len;i++)
|
||||
{
|
||||
if(word[now].al[s[i]-'a']==-1)
|
||||
return 0;
|
||||
now=word[now].al[s[i]-'a'];
|
||||
}
|
||||
return word[now].cnt;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int n,m,len;
|
||||
char s[21];
|
||||
Init(0);
|
||||
scanf("%d",&n);
|
||||
while(n--)
|
||||
{
|
||||
scanf("%s",&s);
|
||||
len=strlen(s);
|
||||
for(int i=0;i<len;i++)
|
||||
Insert(s+i,len-i,n+1);
|
||||
}
|
||||
scanf("%d",&m);
|
||||
while(m--)
|
||||
{
|
||||
scanf("%s",&s);
|
||||
printf("%d\n",find(s));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,49 @@
|
|||
#include <stdio.h>
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
#include <math.h>
|
||||
#include <vector>
|
||||
#include <set>
|
||||
#include <queue>
|
||||
#include <string.h>
|
||||
using namespace std;
|
||||
#define ll __int64
|
||||
ll n, m, k;
|
||||
char s[40], t[40];
|
||||
void go(ll x, char *S){
|
||||
ll top = 1;
|
||||
while(x){ S[top++] = ('0'+(x&1)); x>>=1; }
|
||||
S[top] = 0;
|
||||
}
|
||||
ll z, o;//n涓0 1涓
|
||||
ll Zero(ll x){ll ans = 0; while(x){ans += !(x&1);x>>=1;}return ans;}
|
||||
ll One(ll x){ll ans = 0; while(x){ans += (x&1);x>>=1;}return ans;}
|
||||
ll work(char *c){
|
||||
ll ans = 0, er = 1;
|
||||
for(ll i = strlen(c)-1; i>=0; i--, er<<=1)if(c[i]=='1')ans += er;
|
||||
return ans;
|
||||
}
|
||||
bool ok(ll x){
|
||||
if(Zero(x)<z || One(x)<o)return false;
|
||||
go(x, t);
|
||||
ll len = 0;
|
||||
for(ll i = 1, j = 1; s[i] && t[j]; j++)
|
||||
if(s[i] == t[j])len++, i++;
|
||||
return len == (z+o);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
ll i, j, k;
|
||||
while(~scanf("%s",s))
|
||||
{
|
||||
n = work(s);
|
||||
scanf("%I64d",&m);
|
||||
if(n==0){puts("0");continue;}
|
||||
z = Zero(n), o = One(n);
|
||||
go(n, s);
|
||||
for(i = 1;;i++)if(ok(i*m))break;
|
||||
go(i*m, s);
|
||||
for(i=strlen(s+1); i; i--)printf("%c",s[i]);puts("");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,43 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
#include <queue>
|
||||
using namespace std;
|
||||
const int MAX_N = 22;
|
||||
long long base[MAX_N];
|
||||
void makeBase()
|
||||
{
|
||||
base[0] = 1;
|
||||
for (int i = 1; i <= 18; ++i)
|
||||
base[i] = base[i-1] * 10;
|
||||
}
|
||||
bool dfs (long long n, int k);
|
||||
bool test (long long n, int k, int nPart, long long curSum)
|
||||
{
|
||||
if (nPart == k)
|
||||
return ! dfs (curSum+n, k);
|
||||
for (int i = 1; i < 20; ++i)
|
||||
{
|
||||
long long a = n % base[i];
|
||||
long long b = n / base[i];
|
||||
if (b == 0) break;
|
||||
if (test(b, k, nPart+1, curSum+a))
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
bool dfs (long long n, int k)
|
||||
{
|
||||
if (n < base[k-1]) return false;
|
||||
else return test(n, k, 1, 0);
|
||||
}
|
||||
int main ()
|
||||
{
|
||||
makeBase();
|
||||
int k;
|
||||
long long n;
|
||||
while (cin >> n >> k)
|
||||
cout << dfs(n, k) << endl;
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,58 @@
|
|||
#include<iostream>
|
||||
#include<cstdlib>
|
||||
#include<queue>
|
||||
using namespace std;
|
||||
const int N=100011;
|
||||
int n,m,ans[N];
|
||||
struct node0
|
||||
{
|
||||
int cost,index;
|
||||
}E[N];
|
||||
struct node
|
||||
{
|
||||
int index,load;
|
||||
bool friend operator<(node n1,node n2)
|
||||
{
|
||||
return n2.load<n1.load;
|
||||
}
|
||||
};
|
||||
int cmp(const void *a,const void *b)
|
||||
{
|
||||
node0 *c,*d;
|
||||
c=(node0 *)a;
|
||||
d=(node0 *)b;
|
||||
return d->cost-c->cost;
|
||||
}
|
||||
void solve()
|
||||
{
|
||||
int i;
|
||||
priority_queue<node>q;
|
||||
node now;
|
||||
qsort(E,n,sizeof(E[0]),cmp);
|
||||
for(i=0;i<m;i++) {now.index=i;now.load=0;q.push(now);}
|
||||
for(i=0;i<n;i++)
|
||||
{
|
||||
now=q.top();
|
||||
q.pop();
|
||||
now.load+=E[i].cost;
|
||||
ans[E[i].index]=now.index;
|
||||
q.push(now);
|
||||
}
|
||||
cout<<n<<endl;
|
||||
cout<<ans[0];
|
||||
for(i=1;i<n;i++) cout<<" "<<ans[i];
|
||||
cout<<endl;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int T;
|
||||
int i;
|
||||
scanf("%d",&T);
|
||||
while(T--)
|
||||
{
|
||||
scanf("%d%d",&n,&m);
|
||||
for(i=0;i<n;i++) {scanf("%d",&E[i].cost);E[i].index=i;}
|
||||
solve();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,68 @@
|
|||
#include<iostream>
|
||||
#include<stdio.h>
|
||||
using namespace std;
|
||||
const int MAX=2001;
|
||||
const int MAXINT=999999999;
|
||||
struct point
|
||||
{
|
||||
int x1,x2;
|
||||
int length;
|
||||
}sq[MAX];
|
||||
int map[MAX][MAX];
|
||||
int visit[MAX];
|
||||
int dist[MAX];
|
||||
int n,m;
|
||||
void Dijkstra()
|
||||
{
|
||||
for(int i=1;i<=n;i++)
|
||||
{
|
||||
visit[i]=0;
|
||||
dist[i]=map[1][i];
|
||||
}
|
||||
visit[1]=1;
|
||||
int k,min;
|
||||
for(int i=1;i<n;i++)
|
||||
{
|
||||
min=MAXINT;
|
||||
for(int j=1;j<=n;j++)
|
||||
if(!visit[j]&&dist[j]<min)
|
||||
{
|
||||
min=dist[j];
|
||||
k=j;
|
||||
}
|
||||
visit[k]=1;
|
||||
for(int j=1;j<=n;j++)
|
||||
if(!visit[j]&&dist[k]+map[k][j]<dist[j])
|
||||
dist[j]=dist[k]+map[k][j];
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int num;
|
||||
scanf("%d",&num);
|
||||
while(num--)
|
||||
{
|
||||
scanf("%d%d",&n,&m);
|
||||
for(int i=1;i<=n;i++)
|
||||
scanf("%d%d%d",&sq[i].x1,&sq[i].x2,&sq[i].length);
|
||||
for(int i=1;i<=n;i++)
|
||||
{
|
||||
for(int j=1;j<=n;j++)
|
||||
map[i][j]=MAXINT;
|
||||
map[i][i]=0;
|
||||
}
|
||||
for(int i=1;i<n;i++)
|
||||
for(int j=i+1;j<=n;j++)
|
||||
if(sq[i].x2>=sq[j].x1&&sq[i].x2<=sq[j].x2)
|
||||
map[i][j]=sq[j].length;
|
||||
Dijkstra();
|
||||
int T;
|
||||
for(int i=1;i<=m;i++)
|
||||
{
|
||||
scanf("%d",&T);
|
||||
if(dist[T]==MAXINT) printf("-1\n");
|
||||
else printf("%d\n",sq[1].length+dist[T]);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,87 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
using namespace std;
|
||||
#define N 100010
|
||||
#define Lowbit(x) ((x)&(-x))
|
||||
int C[N];
|
||||
bool vis[N];
|
||||
void add(int x,int num)
|
||||
{
|
||||
while(x < N)
|
||||
{
|
||||
C[x] += num;
|
||||
x += Lowbit(x);
|
||||
}
|
||||
}
|
||||
int Sum(int x)
|
||||
{
|
||||
int ans = 0;
|
||||
while(x > 0)
|
||||
{
|
||||
ans += C[x];
|
||||
x -= Lowbit(x);
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
int binarysearch(int l,int k){
|
||||
int mid, left, right, tmp;
|
||||
left = l + 1;
|
||||
right = N - 1;
|
||||
if(Sum(right) - Sum(l) < k)return -1;
|
||||
while(left <= right){
|
||||
mid = (left + right) >> 1;
|
||||
tmp = Sum(mid) - Sum(l);
|
||||
if(tmp == k){
|
||||
if(vis[mid]){
|
||||
return mid;
|
||||
}
|
||||
right = mid - 1;
|
||||
}
|
||||
else if(tmp > k){
|
||||
if(Sum(mid - 1) - Sum(l) < k)return mid;
|
||||
right = mid - 1;
|
||||
}
|
||||
else {
|
||||
left = mid + 1;
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int p, n, m, T, e, a, k, l, r, mid;
|
||||
while(~scanf("%d",&T))
|
||||
{
|
||||
memset(C,0,sizeof(C));
|
||||
memset(vis,0,sizeof(vis));
|
||||
while(T--)
|
||||
{
|
||||
scanf("%d",&p);
|
||||
switch(p)
|
||||
{
|
||||
case 0:
|
||||
scanf("%d",&e);
|
||||
add(e,1);
|
||||
vis[e] = 1;
|
||||
break;
|
||||
case 1:
|
||||
scanf("%d",&e);
|
||||
m = Sum(e) - Sum(e-1);
|
||||
if(!m)printf("No Elment!\n");
|
||||
else add(e,-1);
|
||||
if(m == 1)vis[e] = 0;
|
||||
break;
|
||||
case 2:
|
||||
scanf("%d%d",&a,&k);
|
||||
m = binarysearch(a,k);
|
||||
if(m == -1)
|
||||
printf("Not Find!\n");
|
||||
else
|
||||
printf("%d\n",m);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,107 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<cmath>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
#define N 55
|
||||
#define MAX 1<<28
|
||||
#define CLR(arr, what) memset(arr, what, sizeof(arr))
|
||||
int map[N][N];
|
||||
int lx[N], ly[N], slack[N];
|
||||
bool visitx[N], visity[N];
|
||||
int match[N];
|
||||
int n, m;
|
||||
bool Hungary(int u)
|
||||
{
|
||||
int temp;
|
||||
visitx[u] = true;
|
||||
for(int i = 1; i <= m; ++i)
|
||||
{
|
||||
if(visity[i])
|
||||
continue;
|
||||
temp = lx[u] + ly[i] - map[u][i];
|
||||
if(temp == 0)
|
||||
{
|
||||
visity[i] = true;
|
||||
if(match[i] == - 1 || Hungary(match[i]))
|
||||
{
|
||||
match[i] = u;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
else
|
||||
slack[i] = min(slack[i], temp);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
bool KM_Perfect_Match()
|
||||
{
|
||||
int temp;
|
||||
CLR(lx, 0);
|
||||
CLR(ly, 0);
|
||||
for(int i = 1; i <= n; ++i)
|
||||
for(int j = 1; j <= m; ++j)
|
||||
lx[i] = max(lx[i], map[i][j]);
|
||||
for(int i = 1; i <= n; ++i)
|
||||
{
|
||||
for(int j = 1; j <= m; ++j)
|
||||
slack[j] = MAX;
|
||||
while(1)
|
||||
{
|
||||
CLR(visitx, false);
|
||||
CLR(visity, false);
|
||||
if(Hungary(i))
|
||||
break;
|
||||
else
|
||||
{
|
||||
temp = MAX;
|
||||
for(int j = 1; j <= m; ++j)
|
||||
if(!visity[j])
|
||||
temp = min(temp, slack[j]);
|
||||
if(temp == MAX)
|
||||
return false;
|
||||
for(int j = 1; j <= n; ++j)
|
||||
if(visitx[j])
|
||||
lx[j] -= temp;
|
||||
for(int j = 1; j <= m; ++j)
|
||||
if(visity[j])
|
||||
ly[j] += temp;
|
||||
else
|
||||
slack[j] -= temp;
|
||||
}
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int finish;
|
||||
int ans, res;
|
||||
while(~scanf("%d%d", &n, &m))
|
||||
{
|
||||
res = ans = 0;
|
||||
CLR(match, -1);
|
||||
CLR(map, 0);
|
||||
for(int i = 1; i <= n; ++i)
|
||||
for(int j = 1; j <= m; ++j)
|
||||
{
|
||||
scanf("%d", &map[i][j]);
|
||||
map[i][j] *= 100;
|
||||
}
|
||||
for(int i = 1; i <= n; ++i)
|
||||
{
|
||||
scanf("%d", &finish);
|
||||
res += map[i][finish];
|
||||
map[i][finish] += 1;
|
||||
}
|
||||
KM_Perfect_Match();
|
||||
for(int i = 1; i <= m; ++i)
|
||||
{
|
||||
if(match[i] != -1)
|
||||
ans += map[ match[i] ][i];
|
||||
}
|
||||
printf("%d %d\n", n - ans % 100, ans / 100 - res / 100);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,39 @@
|
|||
#include<iostream>
|
||||
#include<cstring>
|
||||
using namespace std;
|
||||
const int N=5011;
|
||||
int flag[N];
|
||||
void init()
|
||||
{
|
||||
int i,l,j;
|
||||
int a,b;
|
||||
memset(flag,0,sizeof(flag));
|
||||
for(i=1;i<=5000;i++)
|
||||
{
|
||||
for(l=1;l<=1000;l++)
|
||||
{
|
||||
for(j=1;j<=1000;j++)
|
||||
{
|
||||
a=l*l*j+1;
|
||||
b=l*l+j;
|
||||
if(a%i==0 && b%i) flag[i]=1;
|
||||
if(flag[i]) break;
|
||||
}
|
||||
if(flag[i]) break;
|
||||
}
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
init();
|
||||
int T;
|
||||
int n;
|
||||
cin>>T;
|
||||
while(T--)
|
||||
{
|
||||
cin>>n;
|
||||
if(flag[n]) cout<<"NO"<<endl;
|
||||
else cout<<"YES"<<endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,49 @@
|
|||
#include<iostream>
|
||||
using namespace std;
|
||||
int n,m;
|
||||
struct Matrix{
|
||||
int map[2][2];
|
||||
};
|
||||
Matrix mat,unit;
|
||||
void Initiate(){
|
||||
mat.map[0][0]=2;
|
||||
mat.map[0][1]=1;
|
||||
mat.map[1][0]=1;
|
||||
mat.map[1][1]=1;
|
||||
unit.map[0][0]=unit.map[1][1]=1;
|
||||
unit.map[0][1]=unit.map[1][0]=0;
|
||||
}
|
||||
Matrix Mul(Matrix &a,Matrix &b){
|
||||
Matrix c;
|
||||
for(int i=0;i<2;i++){
|
||||
for(int j=0;j<2;j++){
|
||||
c.map[i][j]=0;
|
||||
for(int k=0;k<2;k++){
|
||||
c.map[i][j]+=a.map[i][k]*b.map[k][j];
|
||||
c.map[i][j]%=m;
|
||||
}
|
||||
}
|
||||
}
|
||||
return c;
|
||||
}
|
||||
Matrix Pow(int n){
|
||||
Matrix p=unit,q=mat;
|
||||
while(n){
|
||||
if(n&1)
|
||||
p=Mul(p,q);
|
||||
n>>=1;
|
||||
q=Mul(q,q);
|
||||
}
|
||||
return p;
|
||||
}
|
||||
int main(){
|
||||
int _case;
|
||||
scanf("%d",&_case);
|
||||
Initiate();
|
||||
while(_case--){
|
||||
scanf("%d%d",&n,&m);
|
||||
Matrix remat=Pow(n);
|
||||
printf("%d\n",remat.map[0][1]);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,50 @@
|
|||
#include<stdio.h>
|
||||
#include<math.h>
|
||||
struct line
|
||||
{
|
||||
double a,b,c;
|
||||
}p,s;
|
||||
double x3, y3, x2, y2, x, y;
|
||||
double xs,xe,ys,ye,ansx,ansy;
|
||||
void jiaodian()
|
||||
{
|
||||
s.a=y-ye;
|
||||
s.b=xe-x;
|
||||
s.c=x*ye-y*xe;
|
||||
if(fabs(p.b)<1e-6)
|
||||
{
|
||||
ansx = -p.c / p.a;
|
||||
ansy = (-s.c - s.a * ansx) / s.b;
|
||||
}
|
||||
else
|
||||
{
|
||||
ansx = (p.c * s.b - p.b * s.c) / (p.b * s.a - s.b * p.a);
|
||||
ansy = (-p.c- p.a* ansx) / p.b;
|
||||
}
|
||||
}
|
||||
void duichen()
|
||||
{
|
||||
double d;
|
||||
p.a=y3-y2;
|
||||
p.b=x2-x3;
|
||||
p.c=x3*y2-y3*x2;
|
||||
d=p.a*p.a+p.b*p.b;
|
||||
x=(p.b * p.b * xs - p.a * p.a * xs - 2 * p.a * p.b * ys - 2 * p.a * p.c) / d;
|
||||
y=(p.a * p.a * ys - p.b * p.b * ys - 2 * p.a * p.b * xs - 2 * p.b * p.c) / d;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int t;
|
||||
scanf("%d",&t);
|
||||
while(t--)
|
||||
{
|
||||
scanf("%lf%lf%lf%lf",&x3,&y3,&x2,&y2);
|
||||
scanf("%lf%lf%lf%lf",&xs,&ys,&xe,&ye);
|
||||
duichen();
|
||||
jiaodian();
|
||||
if(fabs(ansx)<1e-6)ansx=fabs(ansx);
|
||||
if(fabs(ansy)<1e-6)ansy=fabs(ansy);
|
||||
printf("%.3lf %.3lf\n",ansx,ansy);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,148 @@
|
|||
#include<iostream>
|
||||
#include<queue>
|
||||
#include<string.h>
|
||||
#include<stdio.h>
|
||||
using namespace std;
|
||||
struct node
|
||||
{
|
||||
int k,l,r,ans,nl,nr,level;
|
||||
node(){};
|
||||
node(int kk,int ll,int rr,int anss,int nll,int nrr,int le)
|
||||
{
|
||||
k=kk;l=ll;r=rr;ans=anss;level=le;nl=nll;nr=nrr;
|
||||
}
|
||||
friend bool operator<(const node &A,const node &B)
|
||||
{
|
||||
if(A.level==B.level)
|
||||
{
|
||||
return A.ans<B.ans;
|
||||
}
|
||||
return A.level>B.level;
|
||||
}
|
||||
}s,e;
|
||||
bool has[230][15][15][15][15][2];
|
||||
priority_queue<node>q;
|
||||
int map[20][20],b[20][20][20];
|
||||
int n,m,k,ans;
|
||||
int x,y,now;
|
||||
void solve()
|
||||
{
|
||||
if(e.k<0||e.k>(n-e.level-1)*(e.nr-e.nl+1))
|
||||
return;
|
||||
if(has[e.k][e.l][e.r][e.nl][e.nr][1-now]==true)
|
||||
return;
|
||||
q.push(e);
|
||||
has[e.k][e.l][e.r][e.nl][e.nr][1-now]=true;
|
||||
}
|
||||
void bfs(int l)
|
||||
{
|
||||
int i,j;
|
||||
memset(has,0,sizeof(has));
|
||||
q.push(node(0,0,0,0,0,0,-1));
|
||||
while(!q.empty())
|
||||
{
|
||||
s=q.top();
|
||||
q.pop();
|
||||
if(s.k==0&&s.ans>ans)
|
||||
ans=s.ans;
|
||||
if(s.level==n-1)
|
||||
continue;
|
||||
if(s.level!=l)
|
||||
{
|
||||
now=1-now;
|
||||
l=s.level;
|
||||
for(i=0;i<m;i++)
|
||||
{
|
||||
for(j=i;j<m;j++)
|
||||
{
|
||||
e=s;
|
||||
e.level++;
|
||||
e.l=i;
|
||||
e.r=j;
|
||||
e.nl=0;
|
||||
e.nr=m-1;
|
||||
e.k=k-(j-i+1);
|
||||
e.ans=b[e.level][i][j];
|
||||
solve();
|
||||
}
|
||||
}
|
||||
}
|
||||
has[s.k][s.l][s.r][s.nl][s.nr][now]=false;
|
||||
if(s.level==-1)
|
||||
continue;
|
||||
if(s.k>(n-s.level-1)*(s.nr-s.nl+1))
|
||||
continue;
|
||||
for(i=s.nl;i<=s.nr;i++)
|
||||
{
|
||||
for(j=i;j<=s.nr;j++)
|
||||
{
|
||||
if(i<s.nl||j>s.nr||j<s.l||i>s.r)
|
||||
continue;
|
||||
e=s;
|
||||
e.level++;
|
||||
e.l=i;
|
||||
e.r=j;
|
||||
e.k-=(j-i+1);
|
||||
if(i>s.l&&j<s.r)
|
||||
{
|
||||
e.nl=i;
|
||||
e.nr=j;
|
||||
e.ans+=b[e.level][i][j];
|
||||
}
|
||||
else if(i>s.l)
|
||||
{
|
||||
e.nl=i;
|
||||
e.nr=s.nr;
|
||||
e.ans+=b[e.level][i][j];
|
||||
}
|
||||
else if(j<s.r)
|
||||
{
|
||||
e.nl=s.nl;
|
||||
e.nr=j;
|
||||
e.ans+=b[e.level][i][j];
|
||||
}
|
||||
else
|
||||
{
|
||||
e.nl=s.nl;
|
||||
e.nr=s.nr;
|
||||
e.ans+=b[e.level][i][j];
|
||||
}
|
||||
solve();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int i,j;
|
||||
while(scanf("%d%d%d",&n,&m,&k)==3)
|
||||
{
|
||||
ans=0;
|
||||
for(i=0;i<n;i++)
|
||||
{
|
||||
for(j=0;j<m;j++)
|
||||
{
|
||||
scanf("%d",&map[i][j]);
|
||||
ans+=map[i][j];
|
||||
}
|
||||
}
|
||||
for(i=0;i<n;i++)
|
||||
{
|
||||
for(x=0;x<m;x++)
|
||||
{
|
||||
for(y=x;y<m;y++)
|
||||
{
|
||||
if(y==x)
|
||||
b[i][x][y]=map[i][x];
|
||||
else
|
||||
b[i][x][y]=b[i][x][y-1]+map[i][y];
|
||||
}
|
||||
}
|
||||
}
|
||||
ans=0;
|
||||
now=0;
|
||||
bfs(-2);
|
||||
printf("Oil : %d\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,38 @@
|
|||
#include <stdio.h>
|
||||
#include <algorithm>
|
||||
#include <iostream>
|
||||
#include <string.h>
|
||||
using namespace std;
|
||||
int dp[1010][1010];
|
||||
char str[1010][1010];
|
||||
int main()
|
||||
{
|
||||
int n;
|
||||
while(scanf("%d",&n) == 1 && n)
|
||||
{
|
||||
for(int i = 0;i < n;i++)
|
||||
scanf("%s",str[i]);
|
||||
int ans = 1;
|
||||
for(int i = 0;i < n;i++)
|
||||
for(int j = 0;j < n;j++)
|
||||
{
|
||||
if(i == 0 || j == n-1)
|
||||
{
|
||||
dp[i][j] = 1;
|
||||
continue;
|
||||
}
|
||||
int t1 = i, t2 = j;
|
||||
while(t1 >= 0 && t2 < n && str[t1][j] == str[i][t2])
|
||||
{
|
||||
t1--;
|
||||
t2++;
|
||||
}
|
||||
t1 = i - t1;
|
||||
if(t1 >= dp[i-1][j+1]+1)dp[i][j] = dp[i-1][j+1]+1;
|
||||
else dp[i][j] = t1;
|
||||
ans = max(ans,dp[i][j]);
|
||||
}
|
||||
printf("%d\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,68 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cstring>
|
||||
using namespace std;
|
||||
const int N=100111;
|
||||
int n,m,q;
|
||||
int pre[N],val[N];
|
||||
void build()
|
||||
{
|
||||
int i;
|
||||
int a,b;
|
||||
memset(val,-1,sizeof(val));
|
||||
for(i=0;i<n;i++) pre[i]=i;
|
||||
while(m--)
|
||||
{
|
||||
scanf("%d%d",&a,&b);
|
||||
if(val[b]==-1 || a<val[b]) val[b]=a;
|
||||
}
|
||||
}
|
||||
int find(int k)
|
||||
{
|
||||
if(pre[k]==k) return k;
|
||||
pre[k]=find(pre[k]);
|
||||
return pre[k];
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int a,b;
|
||||
char str[11];
|
||||
while(scanf("%d%d%d",&n,&m,&q)!=-1)
|
||||
{
|
||||
build();
|
||||
while(q--)
|
||||
{
|
||||
scanf("%s",str);
|
||||
if(str[0]=='A')
|
||||
{
|
||||
scanf("%d%d",&a,&b);
|
||||
if(pre[b]!=b) printf("Reject\n");
|
||||
else
|
||||
{
|
||||
printf("Accept\n");
|
||||
if(val[b]==-1 || a<val[b]) val[b]=a;
|
||||
}
|
||||
}
|
||||
else if(str[0]=='M')
|
||||
{
|
||||
scanf("%d%d",&a,&b);
|
||||
if(pre[a]!=a || pre[b]!=b || a==b) printf("Reject\n");
|
||||
else
|
||||
{
|
||||
printf("Accept\n");
|
||||
pre[b]=a;
|
||||
if(val[b]!=-1 && (val[a]==-1 || val[b]<val[a])) val[a]=val[b];
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
scanf("%d",&a);
|
||||
if(pre[a]==a && val[a]!=-1) printf("Lowest rate: %d.\n",val[a]);
|
||||
else if(pre[a]==a && val[a]==-1)printf("Company %d is empty.\n",a);
|
||||
else if(pre[a]!=a) printf("Company %d is a part of company %d.\n",a,find(a));
|
||||
}
|
||||
}
|
||||
cout<<endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,30 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cstring>
|
||||
using namespace std;
|
||||
const int N=205;
|
||||
const int M=22;
|
||||
__int64 a[N][N][M],b[N][N][M];
|
||||
void init()
|
||||
{
|
||||
int i,l,j;
|
||||
memset(a,0,sizeof(a));
|
||||
memset(b,0,sizeof(b));
|
||||
a[1][0][1]=1;
|
||||
b[1][1][1]=1;
|
||||
for(i=2;i<=200;i++)
|
||||
for(l=0;l<=i;l++)
|
||||
for(j=1;j<=i && j<=20;j++)
|
||||
{
|
||||
a[i][l][j]=a[i-1][l][j]+b[i-1][l][j-1];
|
||||
if(l) b[i][l][j]=a[i-1][l-1][j-1]+b[i-1][l-1][j];
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
init();
|
||||
int n,m,k;
|
||||
while(scanf("%d%d%d",&n,&m,&k)!=-1)
|
||||
printf("%I64d\n",a[n][m][k]+b[n][m][k]);
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,80 @@
|
|||
#include <list>
|
||||
#include <map>
|
||||
#include <set>
|
||||
#include <queue>
|
||||
#include <string>
|
||||
#include <deque>
|
||||
#include <stack>
|
||||
#include <algorithm>
|
||||
#include <iostream>
|
||||
#include <iomanip>
|
||||
#include <cstdio>
|
||||
#include <cmath>
|
||||
#include <cstdlib>
|
||||
#include <limits.h>
|
||||
#include <time.h>
|
||||
#include <string.h>
|
||||
using namespace std;
|
||||
#define LL long long
|
||||
#define PI acos(-1.0)
|
||||
#define Max INT_MAX
|
||||
#define Min INT_MIN
|
||||
#define eps 1e-8
|
||||
#define N 1001
|
||||
priority_queue<int , vector<int> ,greater<int> > p[701];
|
||||
int s[51];
|
||||
int n,m;
|
||||
bool vis[51];
|
||||
int live,die;
|
||||
void gao(){
|
||||
int i,j,k;
|
||||
live=0,die=0;
|
||||
int t=1;
|
||||
while(live+die<m){
|
||||
i=0;
|
||||
while(i<n && !p[t].empty()){
|
||||
int x=p[t].top();
|
||||
p[t].pop();
|
||||
if(x>=s[i]){
|
||||
die++;
|
||||
i++;
|
||||
}
|
||||
else
|
||||
if(x-1>=s[0]){
|
||||
x--;
|
||||
p[t+1].push(x);
|
||||
}
|
||||
else
|
||||
live++;
|
||||
}
|
||||
while(!p[t].empty()){
|
||||
int x=p[t].top();
|
||||
p[t].pop();
|
||||
if(x-1>=s[0]){
|
||||
x--;
|
||||
p[t+1].push(x);
|
||||
}
|
||||
else
|
||||
live++;
|
||||
}
|
||||
t++;
|
||||
}
|
||||
printf("%d\n",die);
|
||||
}
|
||||
int main(){
|
||||
while(scanf("%d%d",&n,&m)!=EOF){
|
||||
int i,j;
|
||||
for(i=0;i<n;i++)scanf("%d",&s[i]);
|
||||
sort(s,s+n);
|
||||
for(i=0;i<=700;i++)
|
||||
while(!p[i].empty())
|
||||
p[i].pop();
|
||||
for(i=0;i<m;i++){
|
||||
int a,b;
|
||||
scanf("%d%d",&a,&b);
|
||||
p[a].push(b);
|
||||
}
|
||||
gao();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,32 @@
|
|||
#include <stdio.h>
|
||||
int main ()
|
||||
{
|
||||
int n,a,b,i,j,k,t=1;
|
||||
int c[100];
|
||||
while (scanf("%d %d %d",&n,&a,&b)!=EOF)
|
||||
{
|
||||
printf ("Case %d:",t++);
|
||||
i=0;
|
||||
while (n)
|
||||
{
|
||||
c[i]=n%b;
|
||||
n/=b;
|
||||
i++;
|
||||
}
|
||||
c[i]=0;
|
||||
for (k=0;k<i-1;k++)
|
||||
{
|
||||
while (c[k]<a)
|
||||
{
|
||||
c[k]+=b;
|
||||
c[k+1]--;
|
||||
}
|
||||
}
|
||||
while (c[k]==0 && k)
|
||||
k--;
|
||||
while (k)
|
||||
printf (" %d",c[k--]);
|
||||
printf (" %d\n",c[0]);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,143 @@
|
|||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<vector>
|
||||
#define P 1000000007
|
||||
#define MAXM 2
|
||||
#define MAXN 32000
|
||||
typedef long long LL;
|
||||
using namespace std;
|
||||
bool p[MAXN];
|
||||
vector<int> factor;
|
||||
vector<int> prime;
|
||||
struct Matrix {
|
||||
LL mat[MAXM][MAXM];
|
||||
void Zero() {
|
||||
memset(mat, 0, sizeof(mat));
|
||||
}
|
||||
void Unit() {
|
||||
Zero();
|
||||
mat[0][0] = mat[1][1] = 1;
|
||||
}
|
||||
void Build(int k) {
|
||||
Zero();
|
||||
mat[0][1] = 1;
|
||||
mat[0][0] = k - 2;
|
||||
mat[1][0] = k - 1;
|
||||
}
|
||||
};
|
||||
Matrix operator *(Matrix &a, Matrix &b) {
|
||||
int i, j, k;
|
||||
Matrix tmp;
|
||||
tmp.Zero();
|
||||
for (i = 0; i < MAXM; i++) {
|
||||
for (j = 0; j < MAXM; j++) {
|
||||
for (k = 0; k < MAXM; k++)
|
||||
tmp.mat[i][j] += a.mat[i][k] * b.mat[k][j];
|
||||
tmp.mat[i][j] %= P;
|
||||
}
|
||||
}
|
||||
return tmp;
|
||||
}
|
||||
Matrix operator ^(Matrix a, int k) {
|
||||
Matrix tmp;
|
||||
for (tmp.Unit(); k; k >>= 1) {
|
||||
if (k & 1)
|
||||
tmp = tmp * a;
|
||||
a = a * a;
|
||||
}
|
||||
return tmp;
|
||||
}
|
||||
void Factor(int n) {
|
||||
int i;
|
||||
factor.clear();
|
||||
for (i = 1; i * i < n; i++) {
|
||||
if (n % i == 0) {
|
||||
factor.push_back(i);
|
||||
factor.push_back(n / i);
|
||||
}
|
||||
}
|
||||
if (i * i == n)
|
||||
factor.push_back(i);
|
||||
}
|
||||
LL ExtGcd(LL a, LL b, LL &x, LL &y) {
|
||||
LL t, d;
|
||||
if (b == 0) {
|
||||
x = 1;
|
||||
y = 0;
|
||||
return a;
|
||||
}
|
||||
d = ExtGcd(b, a % b, x, y);
|
||||
t = x;
|
||||
x = y;
|
||||
y = t - a / b * y;
|
||||
return d;
|
||||
}
|
||||
LL InvMod(LL a, LL n) {
|
||||
LL x, y;
|
||||
ExtGcd(a, n, x, y);
|
||||
return (x % n + n) % n;
|
||||
}
|
||||
int Count(int x) {
|
||||
int res, i;
|
||||
res = x;
|
||||
for (i = 0; prime[i] * prime[i] <= x; i++) {
|
||||
if (x % prime[i] == 0) {
|
||||
res -= res / prime[i];
|
||||
while (x % prime[i] == 0)
|
||||
x /= prime[i];
|
||||
}
|
||||
}
|
||||
if (x > 1)
|
||||
res -= res / x;
|
||||
return res;
|
||||
}
|
||||
LL F(int n, int k) {
|
||||
LL res;
|
||||
if (n == 1)
|
||||
res = 0;
|
||||
else if (n == 2)
|
||||
res = (LL) k * (k - 1);
|
||||
else if (n == 3)
|
||||
res = (LL) k * (k - 1) % P * (k - 2);
|
||||
else {
|
||||
Matrix g;
|
||||
g.Build(k);
|
||||
g = g ^ (n - 3);
|
||||
res = g.mat[0][0] * k % P * (k - 1) % P * (k - 2);
|
||||
res += g.mat[1][0] * k % P * (k - 1);
|
||||
}
|
||||
return res % P;
|
||||
}
|
||||
LL Burnside(int n, int k) {
|
||||
LL ans;
|
||||
int i;
|
||||
Factor(n);
|
||||
for (i = ans = 0; i < (int) factor.size(); i++) {
|
||||
ans += F(factor[i], k) * Count(n / factor[i]) % P;
|
||||
if (ans >= P)
|
||||
ans -= P;
|
||||
}
|
||||
return ans * InvMod(n, P) % P;
|
||||
}
|
||||
void Init() {
|
||||
int i, j;
|
||||
memset(p, true, sizeof(p));
|
||||
for (i = 2; i < 180; i++) {
|
||||
if (p[i]) {
|
||||
for (j = i * i; j < MAXN; j += i)
|
||||
p[j] = false;
|
||||
}
|
||||
}
|
||||
prime.clear();
|
||||
for (i = 2; i < MAXN; i++) {
|
||||
if (p[i])
|
||||
prime.push_back(i);
|
||||
}
|
||||
}
|
||||
int main() {
|
||||
int n, k;
|
||||
Init();
|
||||
while (~scanf("%d%d", &n, &k))
|
||||
printf("%I64d\n", Burnside(n, k - 1) * k % P);
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,39 @@
|
|||
#include <cstring>
|
||||
#include <cmath>
|
||||
#include <algorithm>
|
||||
#include <iostream>
|
||||
#include <cstdio>
|
||||
using namespace std;
|
||||
#define maxn 1000010
|
||||
bool prime[maxn];
|
||||
void Prime()
|
||||
{
|
||||
memset(prime,true,sizeof(prime));
|
||||
prime[0]=prime[1]=0;
|
||||
for(int i=2;i*i<maxn;i++)
|
||||
if(prime[i])
|
||||
for(int j=2*i;j<maxn;j+=i)
|
||||
prime[j]=0;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
Prime();
|
||||
int n,ans,p;
|
||||
while(scanf("%d",&n)!=EOF)
|
||||
{
|
||||
ans=0;
|
||||
for(int i=1;;i++)
|
||||
{
|
||||
int tmp=3*i*i+3*i+1;
|
||||
if(tmp>n)
|
||||
break;
|
||||
if(prime[tmp])
|
||||
ans++;
|
||||
}
|
||||
if(ans)
|
||||
printf("%d\n",ans);
|
||||
else
|
||||
printf("No Special Prime!\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,51 @@
|
|||
#include <list>
|
||||
#include <map>
|
||||
#include <set>
|
||||
#include <queue>
|
||||
#include <string>
|
||||
#include <deque>
|
||||
#include <stack>
|
||||
#include <algorithm>
|
||||
#include <iostream>
|
||||
#include <iomanip>
|
||||
#include <cstdio>
|
||||
#include <cmath>
|
||||
#include <cstdlib>
|
||||
#include <limits.h>
|
||||
#include <time.h>
|
||||
#include <string.h>
|
||||
using namespace std;
|
||||
#define LL long long
|
||||
#define PI acos(-1.0)
|
||||
#define Max INT_MAX
|
||||
#define Min INT_MIN
|
||||
#define eps 1e-8
|
||||
#define N 201
|
||||
bool g[N][N];
|
||||
bool gg[N][N];
|
||||
int main(){
|
||||
int n,m;
|
||||
while(scanf("%d%d",&n,&m)!=EOF){
|
||||
int i,j,k;
|
||||
memset(g,false,sizeof(g));
|
||||
memset(gg,false,sizeof(gg));
|
||||
while(m--){
|
||||
int a,b;
|
||||
scanf("%d%d",&a,&b);
|
||||
g[a][b]=true;
|
||||
}
|
||||
int res=0;
|
||||
for(i=1;i<=n;i++)
|
||||
for(j=1;j<=n;j++)
|
||||
for(k=1;k<=n;k++)
|
||||
if(g[j][i] && g[i][k]){
|
||||
g[j][k]=gg[j][k]=true;
|
||||
}
|
||||
for(i=1;i<=n;i++)
|
||||
for(j=i+1;j<=n;j++)
|
||||
if(gg[i][j] || gg[j][i])
|
||||
res++;
|
||||
printf("%d\n",n*(n-1)/2-res);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,38 @@
|
|||
#include <iostream>
|
||||
#include <cmath>
|
||||
#include <cstdio>
|
||||
using namespace std;
|
||||
int main()
|
||||
{
|
||||
int prime[100];
|
||||
int k = 0;
|
||||
for(int i=2;i<=500;i++)
|
||||
{
|
||||
bool flag = false;
|
||||
for(int j=2;j<=(int)sqrt((double) i);j++)
|
||||
if( i % j == 0) { flag = true; break;}
|
||||
if(!flag) prime[k++] = i;
|
||||
}
|
||||
int a,b;
|
||||
while(scanf("%d%d",&a,&b)!=EOF)
|
||||
{
|
||||
int w=0,h=0;
|
||||
int c = a,d = b;
|
||||
for(int i=0;i<=94;i++)
|
||||
{
|
||||
while(a % prime[i] == 0 && prime[i] != c)
|
||||
{
|
||||
w++;
|
||||
a /= prime[i];
|
||||
}
|
||||
while(b % prime[i] == 0 && prime[i] != d)
|
||||
{
|
||||
h++;
|
||||
b /= prime[i];
|
||||
}
|
||||
}
|
||||
if( w> h) printf("Win\n");
|
||||
else printf("Lose\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,89 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<vector>
|
||||
#include<algorithm>
|
||||
#include<cstring>
|
||||
#include<queue>
|
||||
#include<set>
|
||||
#include<math.h>
|
||||
#include<string>
|
||||
using namespace std;
|
||||
typedef long long ll;
|
||||
#define PI acos(-1.0)
|
||||
#define INF 2*1e9
|
||||
#define eps 1e-6
|
||||
using namespace std;
|
||||
#define MAXN 100010
|
||||
int n,m;
|
||||
int a[1010][1010];
|
||||
int l[1010],r[1010];
|
||||
char map[1010][1010],map1[1010][1010];
|
||||
bool can[50][50];
|
||||
char ok[5][7]={"wabww","xbcxx", "yacyy","zabcz"};
|
||||
char tar[]= "abc";
|
||||
int solve();
|
||||
int main()
|
||||
{
|
||||
memset(can,0,sizeof(can));
|
||||
memset(map1,0,sizeof(map1));
|
||||
int i,j ,k ;
|
||||
for(i=0;i<111;i++) map1[i][0]='1';
|
||||
for(i=0;i<4;i++)
|
||||
{
|
||||
for(j=1;j<5;j++)
|
||||
{
|
||||
can[ok[i][0]-'a'][ok[i][j]-'a'] = 1;
|
||||
}
|
||||
}
|
||||
while(scanf("%d%d",&n,&m)!=EOF)
|
||||
{
|
||||
for(i=1;i<=n;scanf("%s",map[i++]+1) );
|
||||
int ans =-1;
|
||||
for(k=0;k<strlen(tar);k++)
|
||||
{
|
||||
memset(a,0,sizeof(a));
|
||||
for(i=1;i<=n;i++)
|
||||
for(j=1;j<=m;j++)
|
||||
{
|
||||
map1[i][j] = map[i][j];
|
||||
if(can[ map[i][j]-'a' ][tar[k]-'a'] )
|
||||
map1[i][j] = tar[k];
|
||||
if(map1[i][j]==map1[i-1][j])
|
||||
a[i][j] =1+a[i-1][j];
|
||||
else
|
||||
a[i][j] = 1;
|
||||
}
|
||||
int qqq=solve();
|
||||
if( qqq>ans ) ans =qqq;
|
||||
}
|
||||
printf("%d\n",ans);
|
||||
}
|
||||
}
|
||||
int solve()
|
||||
{
|
||||
int i,j;
|
||||
int ans = -1 ,t;
|
||||
for(i=1;i<=n;i++)
|
||||
{
|
||||
a[i][0]= a[i][m+1] =-1;
|
||||
for(j=1;j<=m;j++)
|
||||
r[j]=l[j] =j;
|
||||
for(j=1;j<=m;j++)
|
||||
{
|
||||
while( map1[i][j] == map1[i][l[j]-1] && a[i][j]<= a[i][l[j]-1] )
|
||||
l[j]= l[l[j]-1 ];
|
||||
}
|
||||
for(j=m;j>=1;j--)
|
||||
{
|
||||
while( map1[i][j]==map1[i][r[j]+1] && a[i][j]<= a[i][ r[j]+1] )
|
||||
r[j] =r[r[j]+1] ;
|
||||
}
|
||||
for(j=1;j<=m;j++)
|
||||
{
|
||||
t= a[i][j]*( r[j]-l[j] +1 );
|
||||
if(t> ans)
|
||||
ans= t;
|
||||
}
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
|
|
@ -0,0 +1,184 @@
|
|||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
#define MAXN 50010
|
||||
struct node
|
||||
{
|
||||
int left,right,sum,lazy,s,e,cnt,cover;
|
||||
};
|
||||
node tree[MAXN<<2];
|
||||
inline void PushUp(int mid,int L,int R,int rt)
|
||||
{
|
||||
tree[rt].left=tree[rt<<1].left;
|
||||
tree[rt].right=tree[rt<<1|1].right;
|
||||
if(tree[rt].left==mid-L+1)
|
||||
tree[rt].left+=tree[rt<<1|1].left;
|
||||
if(tree[rt].right==R-mid)
|
||||
tree[rt].right+=tree[rt<<1].right;
|
||||
tree[rt].sum=max(tree[rt<<1].sum,tree[rt<<1|1].sum);
|
||||
tree[rt].sum=max(tree[rt].sum,tree[rt<<1].right+tree[rt<<1|1].left);
|
||||
}
|
||||
inline void PushDown(int mid,int L,int R,int rt)
|
||||
{
|
||||
if(tree[rt].lazy!=-1)
|
||||
{
|
||||
tree[rt<<1].lazy=tree[rt<<1|1].lazy=tree[rt].lazy;
|
||||
tree[rt<<1].sum=tree[rt<<1].left=tree[rt<<1].right=(mid-L+1)*tree[rt].lazy;
|
||||
tree[rt<<1|1].sum=tree[rt<<1|1].left=tree[rt<<1|1].right=(R-mid)*tree[rt].lazy;
|
||||
tree[rt<<1].s=tree[rt<<1|1].s=tree[rt].s;
|
||||
tree[rt<<1].e=tree[rt<<1|1].e=tree[rt].e;
|
||||
tree[rt].lazy=-1;
|
||||
}
|
||||
}
|
||||
void Update(int x,int y,int val,int L,int R,int rt)
|
||||
{
|
||||
if(x<=L&&R<=y)
|
||||
{
|
||||
tree[rt].lazy=val;
|
||||
tree[rt].sum=tree[rt].left=tree[rt].right=val*(R-L+1);
|
||||
if(val)
|
||||
tree[rt].s=tree[rt].e=-1;
|
||||
else
|
||||
{
|
||||
tree[rt].s=x;
|
||||
tree[rt].e=y;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
int mid=(L+R)>>1;
|
||||
PushDown(mid,L,R,rt);
|
||||
if(x<=mid)
|
||||
Update(x,y,val,L,mid,rt<<1);
|
||||
if(y>mid)
|
||||
Update(x,y,val,mid+1,R,rt<<1|1);
|
||||
PushUp(mid,L,R,rt);
|
||||
}
|
||||
}
|
||||
int New(int x,int L,int R,int rt)
|
||||
{
|
||||
if(L==R)
|
||||
return L;
|
||||
int mid=(L+R)>>1;
|
||||
PushDown(mid,L,R,rt);
|
||||
if(tree[rt<<1].sum>=x)
|
||||
return New(x,L,mid,rt<<1);
|
||||
else if(tree[rt<<1].right+tree[rt<<1|1].left>=x)
|
||||
return mid-tree[rt<<1].right+1;
|
||||
else
|
||||
return New(x,mid+1,R,rt<<1|1);
|
||||
}
|
||||
int Free(int x,int L,int R,int rt)
|
||||
{
|
||||
if(L==R)
|
||||
return rt;
|
||||
int mid=(L+R)>>1;
|
||||
PushDown(mid,L,R,rt);
|
||||
if(x<=mid)
|
||||
return Free(x,L,mid,rt<<1);
|
||||
else
|
||||
return Free(x,mid+1,R,rt<<1|1);
|
||||
}
|
||||
inline void CountUp(int rt)
|
||||
{
|
||||
tree[rt].cnt=tree[rt<<1].cnt+tree[rt<<1|1].cnt;
|
||||
}
|
||||
inline void CountDown(int rt)
|
||||
{
|
||||
if(tree[rt].cover)
|
||||
{
|
||||
tree[rt<<1].cnt=tree[rt<<1|1].cnt=0;
|
||||
tree[rt<<1].cover=tree[rt<<1|1].cover=1;
|
||||
tree[rt].cover=0;
|
||||
}
|
||||
}
|
||||
int Get(int x,int L,int R,int rt)
|
||||
{
|
||||
if(L==R)
|
||||
return L;
|
||||
else
|
||||
{
|
||||
int mid=(L+R)>>1;
|
||||
CountDown(rt);
|
||||
if(tree[rt<<1].cnt>=x)
|
||||
return Get(x,L,mid,rt<<1);
|
||||
else
|
||||
return Get(x-tree[rt<<1].cnt,mid+1,R,rt<<1|1);
|
||||
}
|
||||
}
|
||||
void Count(int x,int val,int L,int R,int rt)
|
||||
{
|
||||
if(L==R)
|
||||
tree[rt].cnt=val;
|
||||
else
|
||||
{
|
||||
int mid=(L+R)>>1;
|
||||
CountDown(rt);
|
||||
if(x<=mid)
|
||||
Count(x,val,L,mid,rt<<1);
|
||||
else
|
||||
Count(x,val,mid+1,R,rt<<1|1);
|
||||
CountUp(rt);
|
||||
}
|
||||
}
|
||||
inline void Reset(int n)
|
||||
{
|
||||
Update(1,n,1,1,n,1);
|
||||
tree[1].cover=1;
|
||||
tree[1].cnt=0;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
char s[12];
|
||||
int n,m,x,y;
|
||||
while(~scanf("%d%d",&n,&m))
|
||||
{
|
||||
Reset(n);
|
||||
while(m--)
|
||||
{
|
||||
scanf(" %s",s);
|
||||
if(!strcmp(s,"Reset"))
|
||||
{
|
||||
Reset(n);
|
||||
puts("Reset Now");
|
||||
}
|
||||
else if(!strcmp(s,"New"))
|
||||
{
|
||||
scanf("%d",&x);
|
||||
if(tree[1].sum>=x)
|
||||
{
|
||||
y=New(x,1,n,1);
|
||||
printf("New at %d\n",y);
|
||||
Count(y,1,1,n,1);
|
||||
Update(y,y+x-1,0,1,n,1);
|
||||
}
|
||||
else
|
||||
puts("Reject New");
|
||||
}
|
||||
else if(!strcmp(s,"Free"))
|
||||
{
|
||||
scanf("%d",&x);
|
||||
y=Free(x,1,n,1);
|
||||
if(tree[y].s<0)
|
||||
puts("Reject Free");
|
||||
else
|
||||
{
|
||||
printf("Free from %d to %d\n",tree[y].s,tree[y].e);
|
||||
Count(tree[y].s,0,1,n,1);
|
||||
Update(tree[y].s,tree[y].e,1,1,n,1);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
scanf("%d",&x);
|
||||
if(x>tree[1].cnt)
|
||||
puts("Reject Get");
|
||||
else
|
||||
printf("Get at %d\n",Get(x,1,n,1));
|
||||
}
|
||||
}
|
||||
putchar('\n');
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,95 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <string.h>
|
||||
#include <string>
|
||||
#include <algorithm>
|
||||
#include <queue>
|
||||
#include <map>
|
||||
#include <vector>
|
||||
#include <set>
|
||||
#include <stack>
|
||||
#include <cmath>
|
||||
using namespace std;
|
||||
#define N 20
|
||||
#define inf 0x3f3f3f3f
|
||||
#define eps 1e-16
|
||||
#define LL long long
|
||||
#define Pi acos(-1)
|
||||
struct Point{
|
||||
double x, y;
|
||||
};
|
||||
Point p[N], pnt[N];
|
||||
int res, t, n;
|
||||
bool mark[N];
|
||||
double dot(double x1, double y1, double x2, double y2){
|
||||
return x1 * x2 + y1 * y2;
|
||||
}
|
||||
double cross(double x1, double y1, double x2, double y2){
|
||||
return x1 * y2 - x2 * y1;
|
||||
}
|
||||
int dblcmp(double n) {
|
||||
if (fabs(n) < eps) {
|
||||
return 0;
|
||||
} else {
|
||||
return n > 0 ? +1 : -1;
|
||||
}
|
||||
}
|
||||
bool segXseg(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4){
|
||||
double c1 = cross(x1 - x3, y1 - y3, x2 - x3, y2 - y3);
|
||||
double c2 = cross(x1 - x4, y1 - y4, x2 - x4, y2 - y4);
|
||||
double c3 = cross(x3 - x1, y3 - y1, x4 - x1, y4 - y1);
|
||||
double c4 = cross(x3 - x2, y3 - y2, x4 - x2, y4 - y2);
|
||||
if (c1 * c2 < -eps && c3 * c4 < -eps) return true;
|
||||
if ((dblcmp(c1) == 0 && dblcmp(dot(x1 - x3, y1 - y3, x2 - x3, y2 - y3)) <= 0) ||
|
||||
(dblcmp(c2) == 0 && dblcmp(dot(x1 - x4, y1 - y4, x2 - x4, y2 - y4)) <= 0) ||
|
||||
(dblcmp(c3) == 0 && dblcmp(dot(x3 - x1, y3 - y1, x4 - x1, y4 - y1)) <= 0) ||
|
||||
(dblcmp(c4) == 0 && dblcmp(dot(x3 - x2, y3 - y2, x4 - x2, y4 - y2)) <= 0)) {
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
bool ok(int k){
|
||||
double c = cross(pnt[t].x - pnt[t - 1].x, pnt[t].y - pnt[t - 1].y, p[k].x - pnt[t].x, p[k].y - pnt[t].y);
|
||||
double d = dot(pnt[t].x - pnt[t - 1].x, pnt[t].y - pnt[t - 1].y, p[k].x - pnt[t].x, p[k].y - pnt[t].y);
|
||||
if (!((c > eps || (fabs(c) < eps && d > 0)))){
|
||||
return false;
|
||||
}
|
||||
Point tmp;
|
||||
for (int i = 0; i <= t - 2; ++i){
|
||||
tmp.x = pnt[t].x + (p[k].x - pnt[t].x) * 100000000.0;
|
||||
tmp.y = pnt[t].y + (p[k].y - pnt[t].y) * 100000000.0;
|
||||
if (segXseg(pnt[i].x, pnt[i].y, pnt[i + 1].x, pnt[i + 1].y, pnt[t].x, pnt[t].y, tmp.x, tmp.y)){
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
void DFS(){
|
||||
int i;
|
||||
for (i = 1; i <= n; ++i){
|
||||
if (res == n) return ;
|
||||
if (!mark[i] && (t < 1 || ok(i))){
|
||||
pnt[++t] = p[i];
|
||||
mark[i] = true;
|
||||
if (t > res) res = t;
|
||||
DFS();
|
||||
t--;
|
||||
mark[i] = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
int main(){
|
||||
int i;
|
||||
while (scanf("%d", &n) != EOF){
|
||||
for (i = 1; i <= n; ++i){
|
||||
scanf("%lf%lf", &p[i].x, &p[i].y);
|
||||
}
|
||||
memset(mark, false, sizeof(mark));
|
||||
pnt[0].x = pnt[0].y = 0;
|
||||
t = 0;
|
||||
res = 0;
|
||||
DFS();
|
||||
printf("%d\n", res);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,46 @@
|
|||
#include<iostream>
|
||||
#include<cstdlib>
|
||||
#include<stdio.h>
|
||||
#include<memory.h>
|
||||
using namespace std;
|
||||
int sg[60][60];
|
||||
char str[60][60];
|
||||
int num[600];
|
||||
int dfs(int x,int y)
|
||||
{
|
||||
memset(num,-1,sizeof(num));
|
||||
for(int i=0;i<x;i++)
|
||||
for(int j=0;j<y;j++)
|
||||
{
|
||||
num[sg[i][y]^sg[x][j]]=1;
|
||||
}
|
||||
for(int i=0;;i++)
|
||||
if(num[i]==-1) return i;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
for(int i=0;i<=50;i++)
|
||||
sg[0][i]=sg[i][0]=i;
|
||||
for(int i=1;i<=50;i++)
|
||||
for(int j=1;j<=50;j++)
|
||||
sg[i][j]=dfs(i,j);
|
||||
int n,m;
|
||||
while(scanf("%d%d",&n,&m)!=EOF)
|
||||
{
|
||||
if(n==0&&m==0) break;
|
||||
int ans=0;
|
||||
for(int i=0;i<n;i++)
|
||||
{
|
||||
scanf("%s",str[i]);
|
||||
for(int j=0;j<m;j++)
|
||||
{
|
||||
if(str[i][j]=='#')
|
||||
{
|
||||
ans^=sg[i][j];
|
||||
}
|
||||
}
|
||||
}
|
||||
if(ans) puts("John");
|
||||
else puts("Jack");
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,114 @@
|
|||
#include <cstdio>
|
||||
#include <algorithm>
|
||||
#include <string>
|
||||
#include <cstring>
|
||||
#include <stack>
|
||||
#include <cmath>
|
||||
#include <queue>
|
||||
#include <list>
|
||||
#include <cstdlib>
|
||||
#include <vector>
|
||||
#include <set>
|
||||
#include <map>
|
||||
#include <sstream>
|
||||
#include <iostream>
|
||||
#include <stack>
|
||||
using namespace std;
|
||||
int n,m,q;
|
||||
struct Node
|
||||
{
|
||||
int e,xia,val;
|
||||
}e1[20001];
|
||||
struct Node2
|
||||
{
|
||||
int e,xia;
|
||||
}e2[2000001];
|
||||
int d1,d2,head1[10001],head2[10001];
|
||||
bool vis[10001];
|
||||
int fat[10001],dis[10001],ans[1000001];
|
||||
void add1(int s,int e,int val)
|
||||
{
|
||||
e1[d1].e=e,e1[d1].val=val,e1[d1].xia=head1[s];
|
||||
head1[s]=d1++;
|
||||
}
|
||||
void add2(int s,int e)
|
||||
{
|
||||
e2[d2].e=e,e2[d2].xia=head2[s];
|
||||
head2[s]=d2++;
|
||||
}
|
||||
int find(int num)
|
||||
{
|
||||
if(fat[num] == num)return num;
|
||||
return fat[num]=find(fat[num]);
|
||||
}
|
||||
void Union(int s,int e)
|
||||
{
|
||||
fat[e]=s;
|
||||
}
|
||||
void tarjan(int s)
|
||||
{
|
||||
int i;
|
||||
vis[s]=true;
|
||||
fat[s]=s;
|
||||
for(i=head1[s];i != -1;i=e1[i].xia)
|
||||
{
|
||||
if(!vis[e1[i].e])
|
||||
{
|
||||
dis[e1[i].e]=dis[s]+e1[i].val;
|
||||
tarjan(e1[i].e);
|
||||
Union(s,e1[i].e);
|
||||
}
|
||||
}
|
||||
for(i=head2[s];i != -1 ;i=e2[i].xia)
|
||||
{
|
||||
if(vis[e2[i].e])
|
||||
{
|
||||
if(dis[e2[i].e] != -1)
|
||||
{
|
||||
ans[i/2]=dis[s]+dis[e2[i].e]-2*dis[find(e2[i].e)];
|
||||
}
|
||||
else ans[i/2]=-1;
|
||||
}
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int i,j,ji1,ji2,ji3;
|
||||
while(~scanf("%d %d %d",&n,&m,&q))
|
||||
{
|
||||
d1=d2=0;
|
||||
memset(head1,-1,sizeof(head1));
|
||||
memset(head2,-1,sizeof(head2));
|
||||
for(i=0;i<m;i++)
|
||||
{
|
||||
scanf("%d %d %d",&ji1,&ji2,&ji3);
|
||||
add1(ji1,ji2,ji3);
|
||||
ji1^=ji2,ji2^=ji1,ji1^=ji2;
|
||||
add1(ji1,ji2,ji3);
|
||||
}
|
||||
for(i=0;i<q;i++)
|
||||
{
|
||||
scanf("%d %d",&ji1,&ji2);
|
||||
add2(ji1,ji2);
|
||||
ji1^=ji2,ji2^=ji1,ji1^=ji2;
|
||||
add2(ji1,ji2);
|
||||
}
|
||||
memset(vis,false,sizeof(vis));
|
||||
for(i=1;i<=n;i++)fat[i]=i;
|
||||
for(i=1;i<=n;i++)
|
||||
{
|
||||
if(!vis[i])
|
||||
{
|
||||
memset(dis,-1,sizeof(dis));
|
||||
dis[i]=0;
|
||||
tarjan(i);
|
||||
}
|
||||
}
|
||||
for(i=0;i<q;i++)
|
||||
{
|
||||
if(ans[i] == -1)puts("Not connected");
|
||||
else printf("%d\n",ans[i]);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,47 @@
|
|||
#include <stdio.h>
|
||||
#include <math.h>
|
||||
int main()
|
||||
{
|
||||
double xQ,yQ;
|
||||
double k1;
|
||||
int a,b,x0,y0,T;
|
||||
while(~scanf("%d",&T))
|
||||
{
|
||||
while(T--)
|
||||
{
|
||||
scanf("%d%d%d%d",&a,&b,&x0,&y0);
|
||||
k1=y0/(x0*1.0);
|
||||
xQ=sqrt((a*a*b*b*1.0)/(a*a*k1*k1+b*b));
|
||||
yQ=k1*xQ;int flag= 0;
|
||||
int w=a*a-b*b;
|
||||
if((x0*x0)/(a*a)+(y0*y0)/(b*b)<1)
|
||||
{
|
||||
printf("In ellipse\n");
|
||||
continue;
|
||||
}
|
||||
if(w < 0)
|
||||
{
|
||||
flag =1;
|
||||
w=-w;
|
||||
}
|
||||
double F1,F2;
|
||||
double c =sqrt(w*1.0);
|
||||
if(flag == 0)
|
||||
{
|
||||
F1 = sqrt((xQ+c)*(xQ+c)+(yQ*yQ));
|
||||
F2 = sqrt((xQ-c)*(xQ-c)+yQ*yQ);
|
||||
}
|
||||
else
|
||||
{
|
||||
F1 = sqrt(xQ*xQ+(yQ+c)*(yQ+c));
|
||||
F2 = sqrt(xQ*xQ+(yQ-c)*(yQ-c));
|
||||
}
|
||||
double t = (sqrt)((xQ*xQ*b*b*b*b)*1.0+(yQ*yQ*a*a*a*a)*1.0);
|
||||
double d =a*a*b*b/(t*1.0);
|
||||
double D=d*d*F1*F2;
|
||||
D = a*a*b*b;
|
||||
printf("%.0lf\n",D);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,114 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
#include<algorithm>
|
||||
#define MAXM 1010
|
||||
#define MAXN 250010
|
||||
#define MAXD 501010
|
||||
#define INF 0x3f3f3f3f
|
||||
int N, M, K, P, a[510], b[510], g[510][510];
|
||||
int size, U[MAXD], D[MAXD], L[MAXD], R[MAXD], C[MAXD];
|
||||
int S[MAXM], H[MAXN], ANS;
|
||||
void read(int X, int *a, int c)
|
||||
{
|
||||
int i, j, x, y, n;
|
||||
memset(a, 0, sizeof(int) * (N + 1));
|
||||
for(i = 0; i < X; i ++)
|
||||
{
|
||||
scanf("%d%d", &x, &y);
|
||||
if(x > y) std::swap(x, y);
|
||||
if(c) y += 2;
|
||||
for(j = x; j <= y; j ++) a[j] = 1;
|
||||
}
|
||||
}
|
||||
void prep(int n, int m)
|
||||
{
|
||||
int i;
|
||||
for(i = 0; i <= m; i ++)
|
||||
{
|
||||
R[i] = i + 1, L[i + 1] = i;
|
||||
U[i] = D[i] = i, S[i] = 0;
|
||||
}
|
||||
R[m] = 0, size = m;
|
||||
for(i = 0; i <= n; i ++) H[i] = -1;
|
||||
}
|
||||
void insert(int r, int c)
|
||||
{
|
||||
++ size;
|
||||
C[size] = c, ++ S[c];
|
||||
D[size] = D[c], U[size] = c, U[D[c]] = size, D[c] = size;
|
||||
if(H[r] == -1) L[size] = R[size] = size, H[r] = size;
|
||||
else L[size] = H[r], R[size] = R[H[r]], L[R[H[r]]] = size, R[H[r]] = size;
|
||||
}
|
||||
void init()
|
||||
{
|
||||
int i, j, k;
|
||||
scanf("%d%d", &N, &M);
|
||||
memset(g, 0, sizeof(g));
|
||||
for(i = 0; i < M; i ++)
|
||||
{
|
||||
scanf("%d", &K), read(K, a, 0);
|
||||
scanf("%d", &P), read(P, b, 1);
|
||||
for(j = 1; j <= N; j ++)
|
||||
if(a[j])
|
||||
for(k = 1; k <= N; k ++)
|
||||
if(b[k]) g[j][k] = 1;
|
||||
}
|
||||
prep(N * N, N + N);
|
||||
for(i = 1; i <= N; i ++)
|
||||
for(j = 1; j <= N; j ++)
|
||||
if(g[i][j]) insert((i - 1) * N + j, i), insert((i - 1) * N + j, N + j);
|
||||
}
|
||||
void remove(int c)
|
||||
{
|
||||
int i, j;
|
||||
R[L[c]] = R[c], L[R[c]] = L[c];
|
||||
for(i = D[c]; i != c; i = D[i])
|
||||
for(j = R[i]; j != i; j = R[j])
|
||||
U[D[j]] = U[j], D[U[j]] = D[j], -- S[C[j]];
|
||||
}
|
||||
void resume(int c)
|
||||
{
|
||||
int i, j;
|
||||
for(i = U[c]; i != c; i = U[i])
|
||||
for(j = L[i]; j != i; j = L[j])
|
||||
U[D[j]] = j, D[U[j]] = j, ++ S[C[j]];
|
||||
R[L[c]] = c, L[R[c]] = c;
|
||||
}
|
||||
void dance()
|
||||
{
|
||||
if(R[0] == 0)
|
||||
{
|
||||
++ ANS;
|
||||
return ;
|
||||
}
|
||||
int i, j, t = INF, id;
|
||||
for(i = R[0]; i != 0; i = R[i])
|
||||
if(S[i] < t) t = S[i], id = i;
|
||||
remove(id);
|
||||
for(i = D[id]; i != id; i = D[i])
|
||||
{
|
||||
for(j = R[i]; j != i; j = R[j]) remove(C[j]);
|
||||
dance();
|
||||
if(ANS > 65535) return ;
|
||||
for(j = L[i]; j != i; j = L[j]) resume(C[j]);
|
||||
}
|
||||
resume(id);
|
||||
}
|
||||
void solve()
|
||||
{
|
||||
ANS = 0;
|
||||
dance();
|
||||
if(ANS > 65535) printf("OVERFLOW!\n");
|
||||
else printf("%d\n", ANS);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int t;
|
||||
scanf("%d", &t);
|
||||
while(t --)
|
||||
{
|
||||
init();
|
||||
solve();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,59 @@
|
|||
#include <iostream>
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
using namespace std;
|
||||
typedef long long LL;
|
||||
const int N = 10000005;
|
||||
const int M = 1000005;
|
||||
bool prime[N];
|
||||
int p[N];
|
||||
int k;
|
||||
void isprime()
|
||||
{
|
||||
k = 0;
|
||||
memset(prime,true,sizeof(prime));
|
||||
for(int i=2;i<N;i++)
|
||||
{
|
||||
if(prime[i])
|
||||
{
|
||||
p[k++] = i;
|
||||
for(int j=i+i;j<N;j+=i)
|
||||
prime[j] = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
LL quick_mod(LL a,LL b,LL m)
|
||||
{
|
||||
LL ans = 1;
|
||||
a %= m;
|
||||
while(b)
|
||||
{
|
||||
if(b&1)
|
||||
{
|
||||
ans = ans * a % m;
|
||||
b--;
|
||||
}
|
||||
b >>= 1;
|
||||
a = a * a % m;
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int n,m,t;
|
||||
isprime();
|
||||
scanf("%d",&t);
|
||||
while(t--)
|
||||
{
|
||||
scanf("%d%d",&n,&m);
|
||||
LL cnt = 0;
|
||||
for(int i=0;i < k;i++)
|
||||
{
|
||||
if(p[i] > n) break;
|
||||
cnt += n / p[i];
|
||||
}
|
||||
LL ans = quick_mod(2,cnt,m);
|
||||
printf("%I64d\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,41 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cmath>
|
||||
#include<cstring>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
const int M=10005;
|
||||
int n,m;
|
||||
struct node{
|
||||
int t,x,y;
|
||||
}E[M];
|
||||
int dp[M];
|
||||
int cmp(node n1,node n2){
|
||||
return n1.t<n2.t;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int i,l;
|
||||
int temp;
|
||||
while(scanf("%d%d",&n,&m),n||m)
|
||||
{
|
||||
for(i=0;i<m;i++) scanf("%d%d%d",&E[i].t,&E[i].x,&E[i].y);
|
||||
sort(E,E+m,cmp);
|
||||
int ans;
|
||||
ans=dp[0]=1;
|
||||
for(i=1;i<m;i++)
|
||||
{
|
||||
dp[i]=0;
|
||||
for(l=i-1;l>=0;l--)
|
||||
{
|
||||
temp=abs(E[i].x-E[l].x)+abs(E[i].y-E[l].y);
|
||||
if(temp>E[i].t-E[l].t) continue;
|
||||
dp[i]=dp[i]>(dp[l]+1)?dp[i]:(dp[l]+1);
|
||||
}
|
||||
if(!dp[i]) dp[i]=1;
|
||||
if(dp[i]>ans) ans=dp[i];
|
||||
}
|
||||
cout<<ans<<endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,159 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
#include <climits>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
#define min(a,b)(a)<(b)?(a):(b)
|
||||
const int INF=INT_MAX;
|
||||
const int maxn=2000;
|
||||
const int maxm=10000000;
|
||||
struct node
|
||||
{
|
||||
int from,to,next,c;
|
||||
}e[maxm];
|
||||
int tot;
|
||||
int head[maxn];
|
||||
void add(int s,int u,int f1,int f2)
|
||||
{
|
||||
e[tot].from=s;
|
||||
e[tot].to=u;
|
||||
e[tot].c=f1;
|
||||
e[tot].next=head[s];
|
||||
head[s]=tot++;
|
||||
e[tot].from=u;
|
||||
e[tot].to=s;
|
||||
e[tot].c=f2;
|
||||
e[tot].next=head[u];
|
||||
head[u]=tot++;
|
||||
}
|
||||
int q[maxn];
|
||||
int cnt[maxn];
|
||||
int d[maxn];
|
||||
int low[maxn];
|
||||
int cur[maxn];
|
||||
int maxflow(int s,int t,int n)
|
||||
{
|
||||
int *front=q,*rear=q;
|
||||
for(int i=0;i<n;i++)
|
||||
{
|
||||
d[i]=n;
|
||||
cnt[i]=0;
|
||||
}
|
||||
cnt[n]=n-1;
|
||||
cnt[0]++;
|
||||
d[t]=0;
|
||||
*rear++=t;
|
||||
while(front<rear)
|
||||
{
|
||||
int v=*front++;
|
||||
for(int i=head[v];i!=-1;i=e[i].next)
|
||||
{
|
||||
if(d[e[i].to]==n&&e[i^1].c>0)
|
||||
{
|
||||
d[e[i].to]=d[v]+1;
|
||||
cnt[n]--;
|
||||
cnt[d[e[i].to]]++;
|
||||
*rear++=e[i].to;
|
||||
}
|
||||
}
|
||||
}
|
||||
int flow=0, u=s, top=0;
|
||||
low[0]=INF;
|
||||
for(int i=0;i<n;i++)
|
||||
cur[i]=head[i];
|
||||
while(d[s]<n)
|
||||
{
|
||||
int &i=cur[u];
|
||||
for(;i!=-1;i=e[i].next)
|
||||
{
|
||||
if(e[i].c>0&&d[u]==d[e[i].to]+1)
|
||||
{
|
||||
low[top+1]=min(low[top],e[i].c);
|
||||
q[++top]=i;
|
||||
u=e[i].to;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if(i!=-1)
|
||||
{
|
||||
if(u==t)
|
||||
{
|
||||
int minf=low[top];
|
||||
for(int p=1,i;p<=top;++p)
|
||||
{
|
||||
i=q[p];
|
||||
e[i].c-=minf;
|
||||
e[i^1].c+=minf;
|
||||
}
|
||||
flow+=minf;
|
||||
u=s;
|
||||
low[0]=INF;
|
||||
top=0;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
int old_du=d[u];
|
||||
cnt[old_du]--;
|
||||
d[u]=n-1;
|
||||
for(int i=head[u];i!=-1;i=e[i].next)
|
||||
if(e[i].c>0&&d[u]>d[e[i].to])
|
||||
d[u]=d[e[i].to];
|
||||
cnt[++d[u]]++;
|
||||
if(d[u]<n)
|
||||
cur[u]=head[u];
|
||||
if(u!=s)
|
||||
{
|
||||
u=e[q[top]].from;
|
||||
--top;
|
||||
}
|
||||
if(cnt[old_du]==0)
|
||||
break;
|
||||
}
|
||||
}
|
||||
return flow;
|
||||
}
|
||||
struct edge
|
||||
{
|
||||
int st,en,c,d;
|
||||
}ta[205];
|
||||
int di[500];
|
||||
int main()
|
||||
{
|
||||
int i, j, k, n, m;
|
||||
int sum;
|
||||
while(scanf("%d %d",&m, &n)!=EOF)
|
||||
{
|
||||
tot = 0;
|
||||
sum = 0;
|
||||
memset(head,-1,sizeof(head));
|
||||
int s = 0;
|
||||
int t = m+2*m;
|
||||
int a,b,c,d;
|
||||
int top = 0;
|
||||
for(i = 1; i <= m; i++)
|
||||
{
|
||||
scanf("%d %d %d %d",&ta[i].st, &ta[i].c, &ta[i].en, &ta[i].d);
|
||||
di[top++] = ta[i].st;
|
||||
di[top++] = ta[i].en;
|
||||
}
|
||||
sort(di,di+top);
|
||||
top--;
|
||||
for(i = 1; i <= top; i++)
|
||||
add(i+m,t,(di[i]-di[i-1])*n,0);
|
||||
for(i = 1; i <= m; i++)
|
||||
{
|
||||
add(s,i,ta[i].c*ta[i].d,0);
|
||||
sum += ta[i].c*ta[i].d;
|
||||
for(j = 1; j <= top; j++)
|
||||
if(ta[i].st<=di[j-1]&&di[j] <=ta[i].en)
|
||||
add(i,j+m,INF,0);
|
||||
}
|
||||
int res = maxflow(s,t,t+1);
|
||||
if(res == sum)
|
||||
printf("Yes\n");
|
||||
else printf("No\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,75 @@
|
|||
#include <iostream>
|
||||
#include <algorithm>
|
||||
#include <cstdlib>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <queue>
|
||||
#include <cmath>
|
||||
#include <stack>
|
||||
#include <map>
|
||||
#pragma comment(linker, "/STACK:1024000000");
|
||||
#define EPS (1e-8)
|
||||
#define LL long long
|
||||
#define ULL unsigned long long int
|
||||
#define _LL __int64
|
||||
#define _INF 0x3f3f3f3f
|
||||
#define Mod 1000000007
|
||||
#define LM(a,b) (((ULL)(a))<<(b))
|
||||
#define RM(a,b) (((ULL)(a))>>(b))
|
||||
using namespace std;
|
||||
map<int,int> Max;
|
||||
int Cal(int x,int n)
|
||||
{
|
||||
if(n == 1)
|
||||
return x;
|
||||
if(n == 2)
|
||||
return x*x;
|
||||
if(Max.find(n) == Max.end())
|
||||
{
|
||||
if(n&1)
|
||||
{
|
||||
int t1 = Cal(x,n/2);
|
||||
int t2 = Cal(x,n/2 + 1);
|
||||
t1 = t1*t2;
|
||||
t1 %= 2009;
|
||||
Max.insert(pair<int,int>(n,t1));
|
||||
return t1;
|
||||
}
|
||||
else
|
||||
{
|
||||
int t1 = Cal(x,n/2);
|
||||
t1 = t1*t1;
|
||||
t1 %= 2009;
|
||||
Max.insert(pair<int,int>(n,t1));
|
||||
return t1;
|
||||
}
|
||||
}
|
||||
return Max[n];
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int n;
|
||||
while(scanf("%d",&n) != EOF)
|
||||
{
|
||||
if(n <= 4)
|
||||
{
|
||||
printf("%d\n",n);
|
||||
}
|
||||
else
|
||||
{
|
||||
if(n%3 == 0)
|
||||
{
|
||||
printf("%d\n",Cal(3,n/3)%2009);
|
||||
}
|
||||
else if(n%3 == 2)
|
||||
{
|
||||
printf("%d\n",(Cal(3,n/3)*2)%2009);
|
||||
}
|
||||
else
|
||||
{
|
||||
printf("%d\n",(Cal(3,n/3 - 1)*4)%2009);
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,157 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
#include <cstdlib>
|
||||
#include <cmath>
|
||||
using namespace std;
|
||||
const int N = 5005;
|
||||
const int M = N << 4;
|
||||
int p[N], n, m, sum, w[N];
|
||||
struct Edge {
|
||||
int u, v, w;
|
||||
void init(int a, int b, int c) {
|
||||
u = a, v = b, w = c;
|
||||
}
|
||||
bool operator <(const Edge& e) const {
|
||||
return w < e.w;
|
||||
}
|
||||
}E[M];
|
||||
int find(int u) {
|
||||
if (p[u] != u)
|
||||
p[u] = find(p[u]);
|
||||
return p[u];
|
||||
}
|
||||
const int lim = 17;
|
||||
struct Tree {
|
||||
struct Edge {
|
||||
int v, w;
|
||||
Edge* next;
|
||||
void init(int a, Edge* e, int b) {
|
||||
v = a;
|
||||
w = b;
|
||||
next = e;
|
||||
}
|
||||
};
|
||||
Edge E[M];
|
||||
Edge* it, * head[N];
|
||||
int pa[N][lim], dep[N], dis[N];
|
||||
int maxv[N][lim];
|
||||
int W[N];
|
||||
int n;
|
||||
void init(int n) {
|
||||
this->n = n;
|
||||
for (int i = 0; i < n; head[i++] = 0);
|
||||
it = E;
|
||||
}
|
||||
void add(int u, int v, int w) {
|
||||
it->init(v, head[u], w);
|
||||
head[u] = it++;
|
||||
it->init(u, head[v], w);
|
||||
head[v] = it++;
|
||||
}
|
||||
int lca(int u, int v) {
|
||||
if (dep[u] > dep[v]) swap(u, v);
|
||||
if (dep[u] < dep[v]) {
|
||||
int d = dep[v] - dep[u];
|
||||
for (int i = 0; i < lim; i++)
|
||||
if (d & (1 << i))
|
||||
v = pa[v][i];
|
||||
}
|
||||
if (u != v) {
|
||||
for (int i = lim - 1; i >= 0; i--)
|
||||
if (pa[u][i] != pa[v][i]) {
|
||||
u = pa[u][i];
|
||||
v = pa[v][i];
|
||||
}
|
||||
u = pa[u][0];
|
||||
}
|
||||
return u;
|
||||
}
|
||||
int query(int u, int v) {
|
||||
if (dep[u] > dep[v]) swap(u, v);
|
||||
int res = -1;
|
||||
if (dep[u] < dep[v]) {
|
||||
int d = dep[v] - dep[u];
|
||||
for (int i = 0; i < lim; i++)
|
||||
if (d & (1 << i)) {
|
||||
res = max(maxv[v][i], res);
|
||||
v = pa[v][i];
|
||||
}
|
||||
}
|
||||
if (u != v) {
|
||||
for (int i = lim - 1; i >= 0; i--) {
|
||||
if (pa[u][i] != pa[v][i]) {
|
||||
res = max(res, maxv[u][i]);
|
||||
res = max(res, maxv[v][i]);
|
||||
u = pa[u][i];
|
||||
v = pa[v][i];
|
||||
}
|
||||
}
|
||||
res = max(res, maxv[u][0]);
|
||||
res = max(res, maxv[v][0]);
|
||||
}
|
||||
return res;
|
||||
}
|
||||
void dfs(int u, int fa) {
|
||||
pa[u][0] = fa;
|
||||
maxv[u][0] = W[u];
|
||||
dep[u] = dep[fa] + 1;
|
||||
for (int i = 1; (1 << i) < n; i++) {
|
||||
pa[u][i] = pa[pa[u][i - 1]][i - 1];
|
||||
maxv[u][i] = max(maxv[u][i - 1], maxv[pa[u][i - 1]][i - 1]);
|
||||
}
|
||||
for (Edge* e = head[u]; e; e = e->next) {
|
||||
int v = e->v;
|
||||
if (v != fa) {
|
||||
W[v] = e->w;
|
||||
dfs(v, u);
|
||||
}
|
||||
}
|
||||
}
|
||||
void run(int rt) {
|
||||
dep[rt] = -1;
|
||||
W[rt] = -1;
|
||||
dfs(rt, rt);
|
||||
}
|
||||
}T;
|
||||
int main() {
|
||||
int u, v, w, c;
|
||||
while (~scanf("%d%d%d", &n, &m, &sum)) {
|
||||
c = 0;
|
||||
for (int i = 1; i <= n; i++) {
|
||||
scanf("%d", &w);
|
||||
E[c].init(0, i, w);
|
||||
c++;
|
||||
}
|
||||
for (int i = 0; i < m; i++) {
|
||||
scanf("%d%d%d", &u, &v, &w);
|
||||
E[c].init(u, v, w);
|
||||
c++;
|
||||
}
|
||||
n++;
|
||||
m += n;
|
||||
T.init(n);
|
||||
int res = 0;
|
||||
sort(E, E + c);
|
||||
int cnt = 0;
|
||||
for (int i = 0; i < n; i++) p[i] = i;
|
||||
for (int i = 0; i < c; i++) {
|
||||
int fu = find(E[i].u), fv = find(E[i].v);
|
||||
if (fu != fv) {
|
||||
p[fu] = fv;
|
||||
res += E[i].w;
|
||||
T.add(E[i].u, E[i].v, E[i].w);
|
||||
cnt++;
|
||||
}
|
||||
if (cnt == n - 1) break;
|
||||
}
|
||||
T.run(0);
|
||||
for (int i = 0; i < sum; i++) {
|
||||
scanf("%d%d", &u, &v);
|
||||
int tmp = T.query(u, v);
|
||||
printf("%d\n", res - tmp);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,60 @@
|
|||
#include <stdio.h>
|
||||
#include <algorithm>
|
||||
#include <iostream>
|
||||
#include <string.h>
|
||||
using namespace std;
|
||||
int val[310][310];
|
||||
int dp[310][310][9][9];
|
||||
int mm[310];
|
||||
void initRMQ(int n,int m)
|
||||
{
|
||||
for(int i = 1;i <= n;i++)
|
||||
for(int j = 1;j <= m;j++)
|
||||
dp[i][j][0][0] = val[i][j];
|
||||
for(int ii = 0; ii <= mm[n]; ii++)
|
||||
for(int jj = 0; jj <= mm[m]; jj++)
|
||||
if(ii+jj)
|
||||
for(int i = 1; i + (1<<ii) - 1 <= n;i++)
|
||||
for(int j = 1; j + (1<<jj) - 1 <= m;j++)
|
||||
{
|
||||
if(ii)dp[i][j][ii][jj] = max(dp[i][j][ii-1][jj],dp[i+(1<<(ii-1))][j][ii-1][jj]);
|
||||
else dp[i][j][ii][jj] = max(dp[i][j][ii][jj-1],dp[i][j+(1<<(jj-1))][ii][jj-1]);
|
||||
}
|
||||
}
|
||||
int rmq(int x1,int y1,int x2,int y2)
|
||||
{
|
||||
int k1 = mm[x2-x1+1];
|
||||
int k2 = mm[y2-y1+1];
|
||||
x2 = x2 - (1<<k1) + 1;
|
||||
y2 = y2 - (1<<k2) + 1;
|
||||
return max(max(dp[x1][y1][k1][k2],dp[x1][y2][k1][k2]),max(dp[x2][y1][k1][k2],dp[x2][y2][k1][k2]));
|
||||
}
|
||||
int main()
|
||||
{
|
||||
mm[0] = -1;
|
||||
for(int i = 1;i <= 305;i++)
|
||||
mm[i] = ((i&(i-1))==0)?mm[i-1]+1:mm[i-1];
|
||||
int n,m;
|
||||
int Q;
|
||||
int r1,c1,r2,c2;
|
||||
while(scanf("%d%d",&n,&m) == 2)
|
||||
{
|
||||
for(int i = 1;i <= n;i++)
|
||||
for(int j = 1;j <= m;j++)
|
||||
scanf("%d",&val[i][j]);
|
||||
initRMQ(n,m);
|
||||
scanf("%d",&Q);
|
||||
while(Q--)
|
||||
{
|
||||
scanf("%d%d%d%d",&r1,&c1,&r2,&c2);
|
||||
if(r1 > r2)swap(r1,r2);
|
||||
if(c1 > c2)swap(c1,c2);
|
||||
int tmp = rmq(r1,c1,r2,c2);
|
||||
printf("%d ",tmp);
|
||||
if(tmp == val[r1][c1] || tmp == val[r1][c2] || tmp == val[r2][c1] || tmp == val[r2][c2])
|
||||
printf("yes\n");
|
||||
else printf("no\n");
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,18 @@
|
|||
#include <iostream>
|
||||
using namespace std;
|
||||
int main(int argc, const char * argv[])
|
||||
{
|
||||
int a,b,set(int, const int = 10,const int = 9, const int = 1);
|
||||
while (cin >>a>>b) {
|
||||
cout<<set(set(a)-set(b),9,10,0)<<endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
int set(int s, const int x, const int y, const int z)
|
||||
{
|
||||
int sum=0;
|
||||
for(int i=1;s>0;s/=x,i*=y) {
|
||||
sum+=(z||(s%x)?s%x:((s-=9),9))*i;
|
||||
}
|
||||
return sum;
|
||||
}
|
||||
|
|
@ -0,0 +1,121 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cmath>
|
||||
#include <algorithm>
|
||||
#include <cstring>
|
||||
using namespace std;
|
||||
const int maxn=50050;
|
||||
char str[maxn];
|
||||
int num[maxn];
|
||||
int sa[maxn];
|
||||
int ran[maxn];
|
||||
int height[maxn];
|
||||
int wa[maxn], wb[maxn], wv[maxn], wd[maxn];
|
||||
int X[maxn], que[maxn];
|
||||
int pos;
|
||||
int cmp(int *r, int a, int b, int l)
|
||||
{
|
||||
return r[a]==r[b]&&r[a+l]==r[b+l];
|
||||
}
|
||||
void da(int *r, int n, int m){
|
||||
int i, j, p, *x = wa, *y = wb, *t;
|
||||
for(i = 0; i < m; i ++) wd[i] = 0;
|
||||
for(i = 0; i < n; i ++) wd[x[i]=r[i]] ++;
|
||||
for(i = 1; i < m; i ++) wd[i] += wd[i-1];
|
||||
for(i = n-1; i >= 0; i --) sa[-- wd[x[i]]] = i;
|
||||
for(j = 1, p = 1; p < n; j *= 2, m = p){
|
||||
for(p = 0, i = n-j; i < n; i ++) y[p ++] = i;
|
||||
for(i = 0; i < n; i ++) if(sa[i] >= j) y[p ++] = sa[i] - j;
|
||||
for(i = 0; i < n; i ++) wv[i] = x[y[i]];
|
||||
for(i = 0; i < m; i ++) wd[i] = 0;
|
||||
for(i = 0; i < n; i ++) wd[wv[i]] ++;
|
||||
for(i = 1; i < m; i ++) wd[i] += wd[i-1];
|
||||
for(i = n-1; i >= 0; i --) sa[-- wd[wv[i]]] = y[i];
|
||||
for(t = x, x = y, y = t, p = 1, x[sa[0]] = 0, i = 1; i < n; i ++){
|
||||
x[sa[i]] = cmp(y, sa[i-1], sa[i], j) ? p - 1: p ++;
|
||||
}
|
||||
}
|
||||
}
|
||||
void calHeight(int *r, int n){
|
||||
int i, j, k = 0;
|
||||
for(i = 1; i <= n; i ++) ran[sa[i]] = i;
|
||||
for(i = 0; i < n; height[ran[i ++]] = k){
|
||||
for(k ? k -- : 0, j = sa[ran[i]-1]; r[i+k] == r[j+k]; k ++);
|
||||
}
|
||||
}
|
||||
int find(int tmp, int n)
|
||||
{
|
||||
int l=0, r=n, mid;
|
||||
while(l<=r)
|
||||
{
|
||||
mid=(l+r)>>1;
|
||||
if(X[mid]==tmp) return mid;
|
||||
else if(X[mid]<tmp) l=mid+1;
|
||||
else r=mid-1;
|
||||
}
|
||||
}
|
||||
bool judge(int mid, int rear, int k)
|
||||
{
|
||||
sort(que,que+rear);
|
||||
int pre=que[0], cnt=1;
|
||||
for(int i=1; i<rear; i++)
|
||||
if(que[i]-pre>=mid) pre=que[i], cnt++;
|
||||
return cnt>=k;
|
||||
}
|
||||
bool check(int mid, int n, int k)
|
||||
{
|
||||
int rear=0;
|
||||
for(int i=1; i<=n; i++)
|
||||
{
|
||||
if(height[i]<mid)
|
||||
{
|
||||
if(judge(mid,rear,k))
|
||||
{
|
||||
pos=sa[i-1];
|
||||
return true;
|
||||
}
|
||||
rear=0, que[rear++]=sa[i];
|
||||
}
|
||||
else que[rear++]=sa[i];
|
||||
}
|
||||
if(judge(mid,rear,k))
|
||||
{
|
||||
pos=sa[n-1];
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int n, k, T;
|
||||
cin >> T;
|
||||
while(T--)
|
||||
{
|
||||
scanf("%d%d",&n,&k);
|
||||
for(int i=0; i<n; i++) scanf("%d",num+i), X[i]=num[i];
|
||||
sort(X,X+n);
|
||||
int ep=0;
|
||||
for(int i=1; i<n; i++)
|
||||
if(X[i]!=X[ep]) X[++ep]=X[i];
|
||||
for(int i=0; i<n; i++)
|
||||
num[i]=find(num[i],ep)+2;
|
||||
num[n]=0;
|
||||
da(num,n+1,n+5);
|
||||
calHeight(num,n);
|
||||
int l=1, r=n, mid, ans=0;
|
||||
while(l<=r)
|
||||
{
|
||||
mid=(l+r)>>1;
|
||||
if(check(mid,n,k))
|
||||
{
|
||||
l=mid+1;
|
||||
ans=mid;
|
||||
}
|
||||
else r=mid-1;
|
||||
}
|
||||
printf("%d\n",ans);
|
||||
for(int i=pos; i<pos+ans; i++) printf("%d\n",X[num[i]-2]);
|
||||
if(T) puts("");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,63 @@
|
|||
#include<cstdio>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
int h[10004];
|
||||
struct add{
|
||||
int t;
|
||||
int a;
|
||||
int minn;
|
||||
}ad[10004];
|
||||
bool cmp(add a, add b){
|
||||
if(a.a == b.a)
|
||||
return a.t > b.t;
|
||||
else
|
||||
return a.a < b.a;
|
||||
}
|
||||
bool comp(add a, int sum){
|
||||
return a.a < sum;
|
||||
}
|
||||
int main(){
|
||||
int n, m, hp;
|
||||
while(~scanf("%d%d%d", &n, &m, &hp)){
|
||||
h[0] = 0;
|
||||
for(int i = 1; i <= n; i++)
|
||||
scanf("%d", &h[i]);
|
||||
for(int i = 0; i < m; i++)
|
||||
{
|
||||
scanf("%d%d", &ad[i].t, &ad[i].a);
|
||||
ad[i].minn = n;
|
||||
}
|
||||
sort(ad, ad+m, cmp);
|
||||
int sum = 0, ans = 0;
|
||||
for(int i = n; i > 0; i--){
|
||||
sum += h[i];
|
||||
if(sum > ans)
|
||||
ans = sum;
|
||||
int n = lower_bound(ad, ad+m, sum, comp) - ad;
|
||||
bool boo = false;
|
||||
for(int j = n; j < m; j++){
|
||||
if(i <= ad[j].minn){
|
||||
boo = true;
|
||||
ad[j].minn -= ad[j].t;
|
||||
sum = 0;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if(!boo)
|
||||
for(int j = n-1; j >= 0; j--){
|
||||
if(i <= ad[j].minn){
|
||||
ad[j].minn -= ad[j].t;
|
||||
sum -= ad[j].a;
|
||||
if(sum < 0){
|
||||
sum = 0;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if(hp-ans <= 0)
|
||||
puts("Die");
|
||||
else
|
||||
printf("%d\n", hp-ans);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,114 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
#include<stdlib.h>
|
||||
#include<math.h>
|
||||
#include<algorithm>
|
||||
const int maxn = 111111;
|
||||
const int maxisn = 21;
|
||||
const double eps = 1e-8;
|
||||
const double pi = acos(-1.0);
|
||||
int dcmp(double x)
|
||||
{
|
||||
if(x > eps) return 1;
|
||||
return x < -eps ? -1 : 0;
|
||||
}
|
||||
struct Point
|
||||
{
|
||||
double x, y;
|
||||
Point(){x = y = 0;}
|
||||
Point(double a, double b)
|
||||
{x = a, y = b;}
|
||||
inline Point operator-(const Point &b)const
|
||||
{return Point(x - b.x, y - b.y);}
|
||||
inline Point operator+(const Point &b)const
|
||||
{return Point(x + b.x, y + b.y);}
|
||||
inline Point operator*(const double &b)const
|
||||
{return Point(x * b, y * b);}
|
||||
inline double dot(const Point &b)const
|
||||
{return x * b.x + y * b.y;}
|
||||
inline double cross(const Point &b, const Point &c)const
|
||||
{return (b.x - x) * (c.y - y) - (c.x - x) * (b.y - y);}
|
||||
inline double Dis(const Point &b)const
|
||||
{return sqrt((*this - b).dot(*this - b));}
|
||||
inline bool InLine(const Point &b, const Point &c)const
|
||||
{return !dcmp(cross(b, c));}
|
||||
inline bool OnSeg(const Point &b, const Point &c)const
|
||||
{return InLine(b, c) && (*this - c).dot(*this - b) < eps;}
|
||||
};
|
||||
inline double min(double a, double b)
|
||||
{return a < b ? a : b;}
|
||||
inline double max(double a, double b)
|
||||
{return a > b ? a : b;}
|
||||
inline double Sqr(double x)
|
||||
{return x * x;}
|
||||
inline double Sqr(const Point &p)
|
||||
{return p.dot(p);}
|
||||
Point LineCross(const Point &a, const Point &b, const Point &c, const Point &d)
|
||||
{
|
||||
double u = a.cross(b, c), v = b.cross(a, d);
|
||||
return Point((c.x * v + d.x * u) / (u + v), (c.y * v + d.y * u) / (u + v));
|
||||
}
|
||||
double LineCrossCircle(const Point &a, const Point &b, const Point &r,
|
||||
double R, Point &p1, Point &p2)
|
||||
{
|
||||
Point fp = LineCross(r, Point(r.x + a.y - b.y, r.y + b.x - a.x), a, b);
|
||||
double rtol = r.Dis(fp);
|
||||
double rtos = fp.OnSeg(a, b) ? rtol : min(r.Dis(a), r.Dis(b));
|
||||
double atob = a.Dis(b);
|
||||
double fptoe = sqrt(R * R - rtol * rtol) / atob;
|
||||
if(rtos > R - eps) return rtos;
|
||||
p1 = fp + (a - b) * fptoe;
|
||||
p2 = fp + (b - a) * fptoe;
|
||||
return rtos;
|
||||
}
|
||||
double SectorArea(const Point &r, const Point &a, const Point &b, double R)
|
||||
{
|
||||
double A2 = Sqr(r - a), B2 = Sqr(r - b), C2 = Sqr(a - b);
|
||||
return R * R * acos((A2 + B2 - C2) * 0.5 / sqrt(A2) / sqrt(B2)) * 0.5;
|
||||
}
|
||||
double TACIA(const Point &r, const Point &a, const Point &b, double R)
|
||||
{
|
||||
double adis = r.Dis(a), bdis = r.Dis(b);
|
||||
if(adis < R + eps && bdis < R + eps) return r.cross(a, b) * 0.5;
|
||||
Point ta, tb;
|
||||
if(r.InLine(a, b)) return 0.0;
|
||||
double rtos = LineCrossCircle(a, b, r, R, ta, tb);
|
||||
if(rtos > R - eps) return SectorArea(r, a, b, R);
|
||||
if(adis < R + eps) return r.cross(a, tb) * 0.5 + SectorArea(r, tb, b, R);
|
||||
if(bdis < R + eps) return r.cross(ta, b) * 0.5 + SectorArea(r, a, ta, R);
|
||||
return r.cross(ta, tb) * 0.5 +
|
||||
SectorArea(r, a, ta, R) + SectorArea(r, tb, b, R);
|
||||
}
|
||||
double SPICA(int n, Point r, double R)
|
||||
{
|
||||
int i;
|
||||
Point ori, p[2];
|
||||
scanf("%lf%lf", &ori.x, &ori.y);
|
||||
p[0] = ori;
|
||||
double res = 0, if_clock_t;
|
||||
for(i = 1; i <= n; ++ i)
|
||||
{
|
||||
if(i == n) p[i & 1] = ori;
|
||||
else scanf("%lf%lf", &p[i & 1].x, &p[i & 1].y);
|
||||
if_clock_t = dcmp(r.cross(p[~i & 1], p[i & 1]));
|
||||
if(if_clock_t < 0) res -= TACIA(r, p[i & 1], p[~i & 1], R);
|
||||
else res += TACIA(r, p[~i & 1], p[i & 1], R);
|
||||
}
|
||||
return fabs(res);
|
||||
}
|
||||
Point boom;
|
||||
int n;
|
||||
double R;
|
||||
int main()
|
||||
{
|
||||
double sx, sy, h, vx, vy;
|
||||
while(scanf("%lf%lf%lf", &sx, &sy, &h) != EOF)
|
||||
{
|
||||
scanf("%lf%lf%lf", &vx, &vy, &R);
|
||||
h = sqrt(2 * h / 10);
|
||||
boom = Point(h * vx + sx, h * vy + sy);
|
||||
scanf("%d", &n);
|
||||
printf("%.2f\n", SPICA(n, boom, R));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,65 @@
|
|||
#include <cstdio>
|
||||
#include <cstdlib>
|
||||
#include <iostream>
|
||||
#include <cstring>
|
||||
using namespace std;
|
||||
bool fg,d[1<<15],vis[1<<15];
|
||||
int tot,k;
|
||||
void read()
|
||||
{
|
||||
memset(vis,0,sizeof vis);
|
||||
fg=false;
|
||||
tot=1<<k;
|
||||
}
|
||||
bool check()
|
||||
{
|
||||
int i=1,j=tot+1;
|
||||
for(;i<=k-1;i++,j++)
|
||||
{
|
||||
if(d[i]!=d[j]) return false;
|
||||
}
|
||||
fg=true;
|
||||
for(i=1;i<=tot;i++) printf("%d",d[i]);
|
||||
}
|
||||
void dfs(int step,int num)
|
||||
{
|
||||
if(fg) return;
|
||||
if(step==tot)
|
||||
{
|
||||
check();
|
||||
return;
|
||||
}
|
||||
for(int i=0;i<tot;i++)
|
||||
{
|
||||
if(!vis[i])
|
||||
{
|
||||
int sk;
|
||||
if((num>>(k-1))==1) sk=num-(1<<(k-1));
|
||||
else sk=num;
|
||||
if(sk==(i>>1))
|
||||
{
|
||||
d[step+k]=i&1;
|
||||
vis[i]=true;
|
||||
dfs(step+1,i);
|
||||
vis[i]=false;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
void go()
|
||||
{
|
||||
printf("%d ",tot);
|
||||
for(int i=1;i<=k;i++) d[i]=0;
|
||||
vis[0]=true;
|
||||
dfs(1,0);
|
||||
printf("\n");
|
||||
}
|
||||
int main()
|
||||
{
|
||||
while(scanf("%d",&k)!=EOF)
|
||||
{
|
||||
read();
|
||||
go();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,36 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
char p1[10001],p2[10001];
|
||||
int main()
|
||||
{
|
||||
int i,j,len1,len2;
|
||||
while(scanf("%s%s",p1,p2)!=EOF)
|
||||
{
|
||||
len1 = strlen(p1);
|
||||
len2 = strlen(p2);
|
||||
if(len1 > len2)
|
||||
{
|
||||
for(i = 0;i <= len1-len2-1;i ++)
|
||||
printf("d %c\n",p1[i]);
|
||||
for(j = 0;j <= len2-1;j ++)
|
||||
{
|
||||
printf("m %c\n",p2[j]);
|
||||
}
|
||||
}
|
||||
else if(len1 == len2)
|
||||
{
|
||||
for(i = 0;i <= len2-1;i ++)
|
||||
{
|
||||
printf("m %c\n",p2[i]);
|
||||
}
|
||||
}
|
||||
else if(len1 < len2)
|
||||
{
|
||||
for(i = 0;i <= len2-len1-1;i ++)
|
||||
printf("a %c\n",p2[i]);
|
||||
for(j = len2-len1;j <= len2-1;j ++)
|
||||
printf("m %c\n",p2[j]);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,110 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cstring>
|
||||
using namespace std;
|
||||
const int N=130;
|
||||
int n,m,tag[520];
|
||||
struct Trie{
|
||||
int count;
|
||||
Trie *fail;
|
||||
Trie *next[N];
|
||||
Trie(){
|
||||
count=0;
|
||||
fail=NULL;
|
||||
memset(next,NULL,sizeof(next));
|
||||
}
|
||||
}*q[5000010];
|
||||
char word[520];
|
||||
char str[1000010];
|
||||
int head,tail;
|
||||
void Insert(char *str,Trie *Root,int id){
|
||||
Trie *loc=Root;
|
||||
int i=0;
|
||||
while(str[i]!='\0'){
|
||||
int id=str[i]-31;
|
||||
if(loc->next[id]==NULL)
|
||||
loc->next[id]=new Trie();
|
||||
loc=loc->next[id];
|
||||
i++;
|
||||
}
|
||||
loc->count=id;
|
||||
}
|
||||
void AC_automation(Trie *Root){
|
||||
Root->fail=NULL;
|
||||
q[head++]=Root;
|
||||
Trie *cur,*tmp;
|
||||
while(head!=tail){
|
||||
cur=q[tail++];
|
||||
tmp=NULL;
|
||||
for(int i=0;i<N;i++){
|
||||
if(cur->next[i]!=NULL){
|
||||
if(cur==Root)
|
||||
cur->next[i]->fail=Root;
|
||||
else{
|
||||
tmp=cur->fail;
|
||||
while(tmp!=NULL){
|
||||
if(tmp->next[i]!=NULL){
|
||||
cur->next[i]->fail=tmp->next[i];
|
||||
break;
|
||||
}
|
||||
tmp=tmp->fail;
|
||||
}
|
||||
if(tmp==NULL)
|
||||
cur->next[i]->fail=Root;
|
||||
}
|
||||
q[head++]=cur->next[i];
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
int query(Trie *Root){
|
||||
int i=0,cnt=0;
|
||||
Trie *loc=Root,*tmp;
|
||||
while(str[i]!='\0'){
|
||||
int id=str[i]-31;
|
||||
while(loc->next[id]==NULL && loc!=Root){
|
||||
loc=loc->fail;
|
||||
}
|
||||
loc=loc->next[id];
|
||||
loc=(loc==NULL)?Root:loc;
|
||||
tmp=loc;
|
||||
while(tmp!=Root && tmp->count!=0){
|
||||
if(tmp->count!=0 && !tag[tmp->count]){
|
||||
cnt++;
|
||||
tag[tmp->count]=1;
|
||||
}
|
||||
tmp=tmp->fail;
|
||||
}
|
||||
i++;
|
||||
}
|
||||
return cnt;
|
||||
}
|
||||
int main(){
|
||||
while(scanf("%d",&n)!=EOF){
|
||||
head=tail=0;
|
||||
Trie *Root=new Trie();
|
||||
getchar();
|
||||
for(int i=1;i<=n;i++){
|
||||
gets(word);
|
||||
Insert(word,Root,i);
|
||||
}
|
||||
AC_automation(Root);
|
||||
scanf("%d",&m);
|
||||
int total=0;
|
||||
for(int i=1;i<=m;i++){
|
||||
memset(tag,0,sizeof(tag));
|
||||
scanf("%s",str);
|
||||
int flag=query(Root);
|
||||
if(flag){
|
||||
printf("web %d:",i);
|
||||
for(int j=1;j<=n;j++)
|
||||
if(tag[j])
|
||||
printf(" %d",j);
|
||||
printf("\n");
|
||||
total++;
|
||||
}
|
||||
}
|
||||
printf("total: %d\n",total);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,19 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cstring>
|
||||
using namespace std;
|
||||
int main(){
|
||||
int n,p,q;
|
||||
while(~scanf("%d%d%d",&n,&p,&q)){
|
||||
if(n%(p+q)==0){
|
||||
puts("WIN");
|
||||
}else {
|
||||
int tmp=n%(p+q);
|
||||
if(tmp<=p){
|
||||
puts("LOST");
|
||||
}else
|
||||
puts("WIN");
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,38 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <math.h>
|
||||
struct node
|
||||
{
|
||||
double x,y,z;
|
||||
}p,q,r,t,t2,t3,t4,t5;
|
||||
int main()
|
||||
{
|
||||
double a,b,hu;
|
||||
while(~scanf("%lf%lf%lf",&p.x,&p.y,&p.z))
|
||||
{
|
||||
scanf("%lf%lf%lf",&q.x,&q.y,&q.z);
|
||||
scanf("%lf",&hu);
|
||||
a=atan(q.y/q.x);
|
||||
r.x=sqrt(q.x*q.x+q.y*q.y);
|
||||
r.y=0;
|
||||
r.z=q.z;
|
||||
b=atan(r.x/r.z);
|
||||
t.x=p.x*cos(a)+p.y*sin(a);
|
||||
t.y=-p.x*sin(a)+p.y*cos(a);
|
||||
t.z=p.z;
|
||||
t2.x=t.x*cos(b)-t.z*sin(b);
|
||||
t2.z=t.x*sin(b)+t.z*cos(b);
|
||||
t2.y=t.y;
|
||||
t3.x=t2.x*cos(hu)-t2.y*sin(hu);
|
||||
t3.y=t2.x*sin(hu)+t2.y*cos(hu);
|
||||
t3.z=t2.z;
|
||||
t4.x=t3.x*cos(b)+t3.z*sin(b);
|
||||
t4.z=-t3.x*sin(b)+t3.z*cos(b);
|
||||
t4.y=t3.y;
|
||||
t5.x=t4.x*cos(a)-t4.y*sin(a);
|
||||
t5.y=t4.x*sin(a)+t4.y*cos(a);
|
||||
t5.z=t4.z;
|
||||
printf("%.3lf %.3lf %.3lf\n",t5.x,t5.y,t5.z);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,46 @@
|
|||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<iostream>
|
||||
#include<utility>
|
||||
#include<string>
|
||||
#include<vector>
|
||||
#include<algorithm>
|
||||
#include<queue>
|
||||
#include<cstdlib>
|
||||
#include<cmath>
|
||||
using namespace std;
|
||||
const double eps=1e-8;
|
||||
int y;
|
||||
double g(double x)
|
||||
{
|
||||
return 42*pow(x,6)+48*pow(x,5)+21*pow(x,2)+10*x;
|
||||
}
|
||||
double f(double x)
|
||||
{
|
||||
return 6*pow(x,7)+8*pow(x,6)+7*pow(x,3)+5*pow(x,2)-y*x;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int T;
|
||||
scanf("%d",&T);
|
||||
while(T--)
|
||||
{
|
||||
scanf("%d",&y);
|
||||
if(g(100.0)-y<=0)
|
||||
{
|
||||
printf("%.4lf\n",f(100.0));
|
||||
continue;
|
||||
}
|
||||
double l=0,r=100,m;
|
||||
while(l+eps<=r)
|
||||
{
|
||||
m=(l+r)/2;
|
||||
if(g(m)-y<0)
|
||||
l=m;
|
||||
else
|
||||
r=m;
|
||||
}
|
||||
printf("%.4lf\n",f(m));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
Loading…
Reference in New Issue