KiritoTRw
GitHub
parent
a34c463144
commit
c9791a72c9
|
|
@ -0,0 +1,64 @@
|
|||
#include<stdio.h>
|
||||
#include<math.h>
|
||||
#include<string.h>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
int n,m;
|
||||
int i,j;
|
||||
struct node{
|
||||
int x,y,sum;
|
||||
}s[520];
|
||||
int a[22][22];
|
||||
int cmp(node a,node b)
|
||||
{
|
||||
if(a.sum!=b.sum)
|
||||
return a.sum>b.sum;
|
||||
else if(a.x!=b.x)
|
||||
return a.x<b.x;
|
||||
else if(a.y!=b.y)
|
||||
return a.y<b.y;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
while(~scanf("%d%d",&n,&m),n||m)
|
||||
{
|
||||
memset(a,0,sizeof(a));
|
||||
memset(s,0,sizeof(s));
|
||||
for(i=1;i<=n;++i)
|
||||
{
|
||||
for(j=1;j<=m;++j)
|
||||
{
|
||||
scanf("%d",&a[i][j]);
|
||||
}
|
||||
}
|
||||
int cnt=0;
|
||||
for(i=1;i<=n;++i)
|
||||
{
|
||||
for(j=1;j<=m;++j)
|
||||
{
|
||||
if(a[i][j]*a[i-1][j]<0)
|
||||
s[cnt].sum+=abs(a[i-1][j]);
|
||||
else
|
||||
s[cnt].sum-=abs(a[i-1][j]);
|
||||
if(a[i][j]*a[i+1][j]<0)
|
||||
s[cnt].sum+=abs(a[i+1][j]);
|
||||
else
|
||||
s[cnt].sum-=abs(a[i+1][j]);
|
||||
if(a[i][j]*a[i][j-1]<0)
|
||||
s[cnt].sum+=abs(a[i][j-1]);
|
||||
else
|
||||
s[cnt].sum-=abs(a[i][j-1]);
|
||||
if(a[i][j]*a[i][j+1]<0)
|
||||
s[cnt].sum+=abs(a[i][j+1]);
|
||||
else
|
||||
s[cnt].sum-=abs(a[i][j+1]);
|
||||
s[cnt].x=i;
|
||||
s[cnt].y=j;
|
||||
cnt++;
|
||||
}
|
||||
}
|
||||
sort(s,s+cnt,cmp);
|
||||
printf("%d %d %d\n",s[0].x,s[0].y,s[0].sum);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,41 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cstring>
|
||||
using namespace std;
|
||||
int dp[2][105][105][10];
|
||||
int val[105];
|
||||
int c1[105];
|
||||
int c2[105];
|
||||
int main()
|
||||
{
|
||||
int n,v1,v2,k;
|
||||
while(scanf("%d%d%d%d",&n,&v1,&v2,&k)!=EOF)
|
||||
{
|
||||
int i;
|
||||
for(i=1;i<=n;i++)
|
||||
scanf("%d%d%d",&c1[i],&c2[i],&val[i]);
|
||||
memset(dp,0,sizeof(dp));
|
||||
int now=0;
|
||||
for(i=1;i<=n;i++)
|
||||
{
|
||||
now=now^1;
|
||||
for(int j=0;j<=v1;j++)
|
||||
{
|
||||
for(int l1=0;l1<=v2;l1++)
|
||||
{
|
||||
for(int l2=0;l2<=k;l2++)
|
||||
{
|
||||
dp[now][j][l1][l2]=dp[now^1][j][l1][l2];
|
||||
if(j>=c1[i]&&dp[now][j][l1][l2]<dp[now^1][j-c1[i]][l1][l2]+val[i])
|
||||
dp[now][j][l1][l2]=dp[now^1][j-c1[i]][l1][l2]+val[i];
|
||||
if(l1>=c2[i]&&dp[now][j][l1][l2]<dp[now^1][j][l1-c2[i]][l2]+val[i])
|
||||
dp[now][j][l1][l2]=dp[now^1][j][l1-c2[i]][l2]+val[i];
|
||||
if(l2>=1&&dp[now][j][l1][l2]<dp[now^1][j][l1][l2-1]+val[i])
|
||||
dp[now][j][l1][l2]=dp[now^1][j][l1][l2-1]+val[i];
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
printf("%d\n",dp[now][v1][v2][k]);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,29 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
int main()
|
||||
{
|
||||
int n,m,i,j,t;
|
||||
int a[105][105],dp[105];
|
||||
scanf("%d",&t);
|
||||
while(t--)
|
||||
{
|
||||
memset(a,0,sizeof(a));
|
||||
memset(dp,0,sizeof(dp));
|
||||
scanf("%d%d",&n,&m);
|
||||
for(i = 1;i<=m;i++)
|
||||
{
|
||||
int x,y,c;
|
||||
scanf("%d%d%d",&x,&y,&c);
|
||||
a[x][y] = max(a[x][y],c);
|
||||
}
|
||||
for(i = 1;i<=n;i++)
|
||||
{
|
||||
for(j = i;j>=1;j--)
|
||||
dp[i] = max(dp[i],dp[j-1]+a[j][i]);
|
||||
}
|
||||
printf("%d\n",dp[n]);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,20 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cstring>
|
||||
using namespace std;
|
||||
int n,num[1010];
|
||||
int main(){
|
||||
int t;
|
||||
scanf("%d",&t);
|
||||
while(t--){
|
||||
scanf("%d",&n);
|
||||
int ans=0;
|
||||
for(int i=0;i<n;i++){
|
||||
scanf("%d",&num[i]);
|
||||
ans+=1*num[i]*(n-1-num[i]);
|
||||
}
|
||||
ans/=2;
|
||||
printf("%.3f\n",1.0-ans*1.0/((n*(n-1)*(n-2))/6));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,44 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cstdlib>
|
||||
#include<cmath>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
__int64 d[100][300];
|
||||
int main()
|
||||
{
|
||||
__int64 A,B,t;
|
||||
while(scanf("%I64d%I64d%I64d",&A,&B,&t)!=-1)
|
||||
{
|
||||
t/=15;
|
||||
B+=t/2;
|
||||
t=(t+1)/2;
|
||||
d[0][0]=1;
|
||||
for(__int64 j=1;j<=3*t;j++)
|
||||
{
|
||||
d[0][j]=0;
|
||||
}
|
||||
for(__int64 i=1;i<=t;i++)
|
||||
{
|
||||
d[i][0]=0;
|
||||
d[i][1]=d[i-1][0];
|
||||
d[i][2]=d[i-1][0]+d[i-1][1];
|
||||
for(__int64 j=3;j<=3*t;j++)
|
||||
{
|
||||
d[i][j]=d[i-1][j-1]+d[i-1][j-2]+d[i-1][j-3];
|
||||
}
|
||||
}
|
||||
__int64 ans=0;
|
||||
__int64 j=B-A+1;
|
||||
if(j<0)
|
||||
{
|
||||
j=0;
|
||||
}
|
||||
for(;j<=3*t;j++)
|
||||
{
|
||||
ans+=d[t][j];
|
||||
}
|
||||
printf("%I64d\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,28 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
int main()
|
||||
{
|
||||
int a, i, c, n, cnt[105];
|
||||
scanf("%d",&c);
|
||||
while(c--)
|
||||
{
|
||||
scanf("%d",&n);
|
||||
memset(cnt, 0, sizeof(cnt));
|
||||
int Max = 0;
|
||||
for(i = 0; i < n; i++)
|
||||
{
|
||||
scanf("%d",&a);
|
||||
cnt[a]++;
|
||||
if(a > Max)
|
||||
Max = a;
|
||||
}
|
||||
int ans = Max * 10;
|
||||
for(i = 1; i <= Max; i++)
|
||||
{
|
||||
if(cnt[i])
|
||||
ans += 5 + cnt[i];
|
||||
}
|
||||
printf("%d\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,32 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cstring>
|
||||
using namespace std;
|
||||
const int mod=1e9+7;
|
||||
long long n,t,k;
|
||||
long long num[10010],res[10010];
|
||||
int main(){
|
||||
int T;
|
||||
scanf("%d",&T);
|
||||
while(T--){
|
||||
scanf("%I64d%I64d%I64d",&n,&t,&k);
|
||||
long long tmpt=t,tmpk=1;
|
||||
while(tmpt){
|
||||
if(tmpt&1)
|
||||
tmpk=(tmpk*k)%mod;
|
||||
tmpt>>=1;
|
||||
k=(k*k)%mod;
|
||||
}
|
||||
for(int i=0;i<n;i++){
|
||||
scanf("%I64d",&num[i]);
|
||||
num[i]=(num[i]*tmpk)%mod;
|
||||
}
|
||||
t=t%n;
|
||||
for(int i=0;i<n;i++)
|
||||
res[(i+t)%n]=num[i];
|
||||
for(int i=0;i<n-1;i++)
|
||||
printf("%I64d ",res[i]);
|
||||
printf("%I64d\n",res[n-1]);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,66 @@
|
|||
#include <math.h>
|
||||
#include <string>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
using namespace std;
|
||||
typedef long long LL;
|
||||
typedef pair< int,pair<LL,LL> > PILL;
|
||||
#define F first
|
||||
#define S second
|
||||
#define MP make_pair
|
||||
const int mod = 1e9 + 7;
|
||||
int digit[20];
|
||||
LL pow10[20];
|
||||
PILL dp[20][7][7][2];
|
||||
bool vis[20][7][7][2];
|
||||
PILL dfs(int len,int sum,int remain,bool contain,bool fp)
|
||||
{
|
||||
if(!len)
|
||||
if(!contain && sum && remain)
|
||||
return MP(1,MP(0LL,0LL));
|
||||
else
|
||||
return MP(0,MP(0LL,0LL));
|
||||
if(!fp && vis[len][sum][remain][contain])
|
||||
return dp[len][sum][remain][contain];
|
||||
PILL ret = MP(0,MP(0,0));
|
||||
int fpmax = fp ? digit[len] : 9;
|
||||
for(int i=0;i<=fpmax;i++)
|
||||
{
|
||||
PILL nxt = dfs(len-1,(sum + i) % 7,(remain * 10 + i) % 7,contain | (i == 7),fp && i == fpmax);
|
||||
LL pref = i * pow10[len-1] % mod;
|
||||
(ret.F += nxt.F) %= mod;
|
||||
(ret.S.F += nxt.S.F + pref * nxt.F) %= mod;
|
||||
(ret.S.S += nxt.S.S + pref * pref % mod * nxt.F + 2 * pref * nxt.S.F) %= mod;
|
||||
}
|
||||
if(!fp)
|
||||
{
|
||||
vis[len][sum][remain][contain] = true;
|
||||
dp[len][sum][remain][contain] = ret;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
long long f(long long n)
|
||||
{
|
||||
int len = 0;
|
||||
while(n)
|
||||
{
|
||||
digit[++len] = n % 10;
|
||||
n /= 10;
|
||||
}
|
||||
return dfs(len,0,0,0,true).S.S;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
pow10[0] = 1;
|
||||
for(int i=1;i<20;i++)
|
||||
pow10[i] = pow10[i-1] * 10 % mod;
|
||||
int T;
|
||||
scanf("%d",&T);
|
||||
while(T--)
|
||||
{
|
||||
long long a,b;
|
||||
scanf("%I64d%I64d",&a,&b);
|
||||
printf("%I64d\n",(f(b) - f(a-1) + mod) % mod);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,27 @@
|
|||
#include<iostream>
|
||||
#include<string.h>
|
||||
const int N=110;
|
||||
using namespace std;
|
||||
int dp[N*N*10];
|
||||
struct Node{
|
||||
int a,b;
|
||||
}node[N];
|
||||
int main(){
|
||||
int n;
|
||||
while(~scanf("%d",&n)){
|
||||
for(int i=0;i<n;i++){
|
||||
scanf("%d%d",&node[i].a,&node[i].b);
|
||||
}
|
||||
int m;
|
||||
scanf("%d",&m);
|
||||
memset(dp,0,sizeof(dp));
|
||||
for(int i=0;i<n;i++){
|
||||
for(int j=0;j<=m;j++){
|
||||
if(j<node[i].b)continue;
|
||||
dp[j]=max(dp[j],dp[j-node[i].b]+node[i].a);
|
||||
}
|
||||
}
|
||||
printf("%d\n",dp[m]);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,53 @@
|
|||
#include<cstdio>
|
||||
#include<stdlib.h>
|
||||
const int maxn=500005;
|
||||
struct time
|
||||
{
|
||||
int start;
|
||||
int end;
|
||||
}t[maxn];
|
||||
int cmp(const void*a,const void*b)
|
||||
{
|
||||
time*c=(time*)a;
|
||||
time*d=(time*)b;
|
||||
return c->start-d->start;
|
||||
}
|
||||
int max(int a,int b)
|
||||
{
|
||||
return a>b?a:b;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int N;
|
||||
while(~scanf("%d",&N))
|
||||
{
|
||||
int a,b,c,d;
|
||||
char ss;
|
||||
int i;
|
||||
for(i=0;i<N;i++)
|
||||
{
|
||||
scanf("%d%c%d%d%c%d",&a,&ss,&b,&c,&ss,&d);
|
||||
t[i].start=a*60+b;
|
||||
t[i].end=c*60+d;
|
||||
}
|
||||
qsort(t,N,sizeof(t[0]),cmp);
|
||||
int starttime=t[0].start,endtime=t[0].end;
|
||||
int alltime=0;
|
||||
for(i=1;i<N;i++)
|
||||
{
|
||||
if(t[i].start<=endtime)
|
||||
{
|
||||
endtime=max(endtime,t[i].end);
|
||||
}
|
||||
else
|
||||
{
|
||||
alltime+=(endtime-starttime);
|
||||
starttime=t[i].start;
|
||||
endtime=t[i].end;
|
||||
}
|
||||
}
|
||||
alltime+=(endtime-starttime);
|
||||
printf("%d\n",1440-alltime);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,34 @@
|
|||
#include<stdio.h>
|
||||
int main(){
|
||||
int h,m,s,a,b,c,T;
|
||||
scanf("%d",&T);
|
||||
while(T--) {
|
||||
scanf("%d%*c%d%*c%d",&h,&m,&s);
|
||||
scanf("%d%*c%d%*c%d",&a,&b,&c);
|
||||
a=a%12;
|
||||
s=s-c;
|
||||
if(s<0) {
|
||||
s+=60;
|
||||
m--;
|
||||
if(m<0){
|
||||
m+=60;
|
||||
h--;
|
||||
if(h<0) h+=12;
|
||||
}
|
||||
}
|
||||
m-=b;
|
||||
if(m<0){
|
||||
m+=60;
|
||||
h--;
|
||||
if(h<0) h+=12;
|
||||
}
|
||||
h=(h-a+12)%12;
|
||||
if(h<10) printf("0%d:",h);
|
||||
else printf("%d:",h);
|
||||
if(m<10) printf("0%d:",m);
|
||||
else printf("%d:",m);
|
||||
if(s<10) printf("0%d\n",s);
|
||||
else printf("%d\n",s);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,127 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
#include <vector>
|
||||
#include <queue>
|
||||
#include <set>
|
||||
#include <map>
|
||||
#include <string>
|
||||
#include <math.h>
|
||||
#include <stdlib.h>
|
||||
#include <time.h>
|
||||
using namespace std;
|
||||
const double INF = 1e20;
|
||||
int n;
|
||||
pair<int,int> p[100];
|
||||
double dis(pair<int,int>a,pair<int,int>b)
|
||||
{
|
||||
return sqrt((double)(1.0 * a.first - b.first) * (1.0 * a.first - b.first) + (double)(1.0 * a.second - b.second)*(1.0 * a.second - b.second));
|
||||
}
|
||||
double dp[55][1000];
|
||||
void CheckMin(double &a,double b)
|
||||
{
|
||||
a = min(a,b);
|
||||
}
|
||||
struct Trie
|
||||
{
|
||||
int next[1000][55],fail[1000],end[1000];
|
||||
int root,L;
|
||||
int newnode()
|
||||
{
|
||||
for(int i = 1; i <= n;i++)
|
||||
next[L][i] = -1;
|
||||
end[L++] = 0;
|
||||
return L-1;
|
||||
}
|
||||
void init()
|
||||
{
|
||||
L = 0;
|
||||
root = newnode();
|
||||
}
|
||||
void insert(int a[],int cnt)
|
||||
{
|
||||
int now = root;
|
||||
for(int i = 0;i < cnt;i++)
|
||||
{
|
||||
if(next[now][a[i]] == -1)
|
||||
next[now][a[i]] = newnode();
|
||||
now = next[now][a[i]];
|
||||
}
|
||||
end[now] = 1;
|
||||
}
|
||||
void build()
|
||||
{
|
||||
queue<int>Q;
|
||||
fail[root] = root;
|
||||
for(int i = 1;i <= n;i++)
|
||||
if(next[root][i] == -1)
|
||||
next[root][i] = root;
|
||||
else
|
||||
{
|
||||
fail[next[root][i]] = root;
|
||||
Q.push(next[root][i]);
|
||||
}
|
||||
while(!Q.empty())
|
||||
{
|
||||
int now = Q.front();
|
||||
Q.pop();
|
||||
end[now] |= end[fail[now]];
|
||||
for(int i = 1;i <= n;i++)
|
||||
if(next[now][i] == -1)
|
||||
next[now][i] = next[fail[now]][i];
|
||||
else
|
||||
{
|
||||
fail[next[now][i]] = next[fail[now]][i];
|
||||
Q.push(next[now][i]);
|
||||
}
|
||||
}
|
||||
}
|
||||
void solve()
|
||||
{
|
||||
for(int i = 1;i <= n;i++)
|
||||
for(int j = 0;j < L;j++)
|
||||
dp[i][j] = INF;
|
||||
dp[1][next[root][1]] = 0;
|
||||
for(int i = 1;i < n;i++)
|
||||
for(int j = 0;j < L;j++)
|
||||
if(dp[i][j] < INF)
|
||||
{
|
||||
for(int k = i+1;k <= n;k++)
|
||||
{
|
||||
int ss = next[j][k];
|
||||
if(end[ss])continue;
|
||||
CheckMin(dp[k][ss],dp[i][j] + dis(p[i],p[k]));
|
||||
}
|
||||
}
|
||||
double ans = INF;
|
||||
for(int i = 0;i < L;i++)
|
||||
if(dp[n][i] < INF)
|
||||
CheckMin(ans,dp[n][i]);
|
||||
if(ans == INF)printf("Can not be reached!\n");
|
||||
else printf("%.2f\n",ans);
|
||||
}
|
||||
}ac;
|
||||
int a[10];
|
||||
int main()
|
||||
{
|
||||
int m;
|
||||
while(scanf("%d%d",&n,&m) == 2)
|
||||
{
|
||||
if(n == 0 && m == 0)break;
|
||||
for(int i = 1;i <= n;i++)
|
||||
scanf("%d%d",&p[i].first,&p[i].second);
|
||||
ac.init();
|
||||
int k;
|
||||
while(m--)
|
||||
{
|
||||
scanf("%d",&k);
|
||||
for(int i = 0;i < k;i++)
|
||||
scanf("%d",&a[i]);
|
||||
ac.insert(a,k);
|
||||
}
|
||||
ac.build();
|
||||
ac.solve();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,40 @@
|
|||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#define MAXN 205
|
||||
int a[MAXN];
|
||||
int f[MAXN][MAXN];
|
||||
int main()
|
||||
{
|
||||
int T, N;
|
||||
for(scanf("%d", &T); T--; )
|
||||
{
|
||||
scanf("%d", &N);
|
||||
for(int i = 1; i <= N; ++i)
|
||||
scanf("%d", &a[i]);
|
||||
memset(f, 0, sizeof(f));
|
||||
int ans = 1;
|
||||
for(int i = 1; i <= N; ++i)
|
||||
{
|
||||
int max = 0;
|
||||
for(int j = N; i < j; --j)
|
||||
{
|
||||
f[i][j] = f[i-1][j];
|
||||
if((a[i] == a[j]) && (f[i][j] < max + 1))
|
||||
f[i][j] = max + 1;
|
||||
else if((a[i] > a[j]) &&(f[i-1][j] > max)) max = f[i-1][j];
|
||||
if(f[i][j] * 2 > ans) ans = f[i][j] * 2;
|
||||
for(int k = i + 1; k < j; ++k)
|
||||
{
|
||||
if(a[k] > a[j])
|
||||
{
|
||||
if(2 * f[i][j] + 1 > ans)
|
||||
ans = 2 * f[i][j] + 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
printf("%d\n", ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,61 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
#define MAXN 100005
|
||||
int a[MAXN * 2];
|
||||
struct Rem{
|
||||
int left;
|
||||
int right;
|
||||
}rem;
|
||||
int odd[2 * MAXN];
|
||||
int min(int a, int b)
|
||||
{
|
||||
return (a < b) ? a : b;
|
||||
}
|
||||
int fun(int i, int m, int N)
|
||||
{
|
||||
int l = i - m - 1, r = i + m + 1;
|
||||
int ret = 0;
|
||||
for(;(l > 0)&&(r <= N);--l, ++r)
|
||||
{
|
||||
if((a[r] == -1) || ((a[l] == a[r]) && ((r - l == 2)||(a[r] <= a[r - 2]) )))
|
||||
++ret;
|
||||
else break;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int T, N;
|
||||
for(scanf("%d", &T); T--; )
|
||||
{
|
||||
scanf("%d", &N);
|
||||
int i = 0;
|
||||
a[++i] = -1;
|
||||
while(N--)
|
||||
{
|
||||
scanf("%d", &a[++i]);
|
||||
a[++i] = -1;
|
||||
}
|
||||
N = i;
|
||||
rem.left = rem.right = 0;
|
||||
int ans = 1;
|
||||
memset(odd, 0, sizeof(odd));
|
||||
for(int i = 1; i <= N; ++i)
|
||||
{
|
||||
int m = 0;
|
||||
if(rem.right > i)
|
||||
m = min(rem.right - i, odd[rem.left + (rem.right - i)]);
|
||||
odd[i] = m + fun(i, m, N);
|
||||
if(i + odd[i] > rem.right)
|
||||
{
|
||||
rem.left = i - odd[i];
|
||||
rem.right = i + odd[i];
|
||||
}
|
||||
if(odd[i] > ans)
|
||||
ans = odd[i];
|
||||
}
|
||||
printf("%d\n", ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,64 @@
|
|||
#include <cstdlib>
|
||||
#include <cstring>
|
||||
#include <cstdio>
|
||||
#include <algorithm>
|
||||
#include <vector>
|
||||
#pragma comment(linker, "/STACK:1024000000,1024000000")
|
||||
using namespace std;
|
||||
const int N = 100005;
|
||||
int n, m, ans;
|
||||
int set[N];
|
||||
int dp[N];
|
||||
struct Edge {
|
||||
int v, f;
|
||||
Edge() {}
|
||||
Edge(int _v, int _f) : v(_v), f(_f) {}
|
||||
};
|
||||
vector<Edge>vt[N];
|
||||
int find(int x) {
|
||||
return x == set[x] ? x : x = find(set[x]);
|
||||
}
|
||||
void dfs(int p, int u) {
|
||||
int forkmax = 0;
|
||||
for (int i = 0; i < (int)vt[u].size(); ++i) {
|
||||
int v = vt[u][i].v, f = vt[u][i].f;
|
||||
if (v == p) continue;
|
||||
dfs(u, v);
|
||||
ans = max(ans, dp[v]+f+forkmax);
|
||||
forkmax = max(forkmax, dp[v] + f);
|
||||
}
|
||||
dp[u] = forkmax;
|
||||
}
|
||||
void solve() {
|
||||
for (int i = 1; i <= n; ++i) {
|
||||
if (dp[i] == -1) dfs(0, i);
|
||||
}
|
||||
printf("%d\n", ans);
|
||||
}
|
||||
int main() {
|
||||
while (scanf("%d %d", &n, &m) != EOF) {
|
||||
int a, b, c, x, y;
|
||||
bool loop = false;
|
||||
ans = 0;
|
||||
for (int i = 1; i <= n; ++i) {
|
||||
dp[i] = -1;
|
||||
set[i] = i;
|
||||
vt[i].clear();
|
||||
}
|
||||
for (int i = 0; i < m; ++i) {
|
||||
scanf("%d %d %d", &a, &b, &c);
|
||||
if (loop) continue;
|
||||
x = find(a), y = find(b);
|
||||
if (x != y) set[x] = y;
|
||||
else loop = true;
|
||||
vt[a].push_back(Edge(b, c));
|
||||
vt[b].push_back(Edge(a, c));
|
||||
}
|
||||
if (loop) {
|
||||
puts("YES");
|
||||
continue;
|
||||
}
|
||||
solve();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,68 @@
|
|||
#include <stdio.h>
|
||||
int a[] = {0,31,28,31,30,31,30,31,31,30,31,30,31};
|
||||
const int Y = 2013,M = 3,D = 24;
|
||||
int leap(int y)
|
||||
{
|
||||
if(y%400 == 0 || (y%4==0 && y%100!=0))
|
||||
return 1;
|
||||
return 0;
|
||||
}
|
||||
void deal1(int k)
|
||||
{
|
||||
int y = Y,m = M,d = D;
|
||||
while(k--)
|
||||
{
|
||||
if(leap(y))
|
||||
a[2] = 29;
|
||||
else
|
||||
a[2] = 28;
|
||||
d--;
|
||||
if(d<=0)
|
||||
{
|
||||
m--;
|
||||
if(m<=0)
|
||||
{
|
||||
m = 12;
|
||||
y--;
|
||||
}
|
||||
d = a[m];
|
||||
}
|
||||
}
|
||||
printf("%04d/%02d/%02d",y,m,d);
|
||||
}
|
||||
void deal2(int k)
|
||||
{
|
||||
int y = Y,m = M,d = D;
|
||||
while(k--)
|
||||
{
|
||||
if(leap(y))
|
||||
a[2] = 29;
|
||||
else
|
||||
a[2] = 28;
|
||||
d++;
|
||||
if(d>a[m])
|
||||
{
|
||||
m++;
|
||||
if(m>12)
|
||||
{
|
||||
m = 1;
|
||||
y++;
|
||||
}
|
||||
d = 1;
|
||||
}
|
||||
}
|
||||
printf("%04d/%02d/%02d ",y,m,d);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int n,m;
|
||||
scanf("%d",&n);
|
||||
while(n--)
|
||||
{
|
||||
scanf("%d",&m);
|
||||
deal2(m);
|
||||
deal1(m);
|
||||
printf("\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,122 @@
|
|||
#include <cstdlib>
|
||||
#include <cstring>
|
||||
#include <cstdio>
|
||||
#include <algorithm>
|
||||
#include <cctype>
|
||||
#include <vector>
|
||||
using namespace std;
|
||||
char str[500];
|
||||
int seq[10];
|
||||
long long _pow(int a, int b) {
|
||||
long long ret = 1;
|
||||
for (int i = 0; i < b; ++i) {
|
||||
ret *= a;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
int jiechen[10] = {1, 1, 2, 6, 24, 120};
|
||||
void qiudao(int *rec, int k) {
|
||||
for (int i = k; i <= 5; ++i) {
|
||||
rec[i-k] = jiechen[i] / jiechen[i-k] * seq[i];
|
||||
}
|
||||
}
|
||||
bool judge(int rec[], int x) {
|
||||
long long sum = 0;
|
||||
for (int i = 0; i <= 5; ++i) {
|
||||
sum += 1LL * rec[i] * _pow(x, i);
|
||||
}
|
||||
return sum == 0;
|
||||
}
|
||||
void gao(char ts[]) {
|
||||
int len = strlen(ts);
|
||||
int p = -1, a, b;
|
||||
for (int i = 0; i < len; ++i) {
|
||||
if (ts[i] == 'x') {
|
||||
if (isdigit(ts[i-1])) {
|
||||
ts[i] = '\0';
|
||||
} else {
|
||||
ts[i] = '1';
|
||||
}
|
||||
p = -2;
|
||||
} else if (ts[i] == '^') {
|
||||
ts[i] = '\0';
|
||||
p = i+1;
|
||||
}
|
||||
}
|
||||
a = atoi(ts);
|
||||
if (!a && p != -1) a = 1;
|
||||
if (p == -1) {
|
||||
b = 0;
|
||||
} else if (p == -2) {
|
||||
b = 1;
|
||||
}else {
|
||||
b = atoi(ts+p);
|
||||
}
|
||||
seq[b] += a;
|
||||
}
|
||||
void solve() {
|
||||
vector<int>v;
|
||||
int cnt = 0;
|
||||
memset(seq, 0, sizeof (seq));
|
||||
char ts[50], *p;
|
||||
p = strtok(str, "+");
|
||||
while (p) {
|
||||
strcpy(ts, p);
|
||||
gao(ts);
|
||||
p = strtok(NULL, "+");
|
||||
}
|
||||
for (int i = 5; i >= 0; --i) {
|
||||
if (seq[i] != 0) {
|
||||
cnt = i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
for (int i = -1000; i <= 1000; ++i) {
|
||||
for (int j = 0; j < cnt; ++j) {
|
||||
int rec[10] = {0};
|
||||
qiudao(rec, j);
|
||||
if (judge(rec, i)) {
|
||||
v.push_back(i);
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (v.size() != cnt || seq[cnt] != 1 || cnt == 0) {
|
||||
printf("-1\n");
|
||||
} else {
|
||||
sort(v.begin(), v.end());
|
||||
for (int i = v.size()-1; i >= 0; --i) {
|
||||
if (v[i] < 0) {
|
||||
printf("(x+%d)", -v[i]);
|
||||
} else if (v[i] == 0) {
|
||||
printf("x");
|
||||
} else {
|
||||
printf("(x-%d)", v[i]);
|
||||
}
|
||||
}
|
||||
puts("");
|
||||
}
|
||||
}
|
||||
int main() {
|
||||
int T, ca = 0;
|
||||
scanf("%d", &T);
|
||||
while (T--) {
|
||||
scanf("%s", str);
|
||||
int len = strlen(str);
|
||||
for (int i = 0; i < len; ++i) {
|
||||
if (str[i] == '-') {
|
||||
for (int j = len-1; j >= i; --j) {
|
||||
str[j+1] = str[j];
|
||||
}
|
||||
str[i] = '+';
|
||||
len += 1;
|
||||
++i;
|
||||
str[len] = '\0';
|
||||
}
|
||||
}
|
||||
printf("Case #%d: ", ++ca);
|
||||
solve();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,76 @@
|
|||
#include <cstdio>
|
||||
#include <cstdlib>
|
||||
#include <sstream>
|
||||
#include <iostream>
|
||||
#include <cmath>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
#include <string>
|
||||
#include <utility>
|
||||
#include <vector>
|
||||
#include <queue>
|
||||
#include <stack>
|
||||
#include <map>
|
||||
#include <set>
|
||||
using namespace std;
|
||||
typedef long long ll;
|
||||
#define REP(i,n) for(int i=0;i < (n);i++)
|
||||
#define REPD(i,n) for(int i=(n-1);i >= 0;i--)
|
||||
#define FOR(i,s,t) for(int i = (s);i <= (t);i++)
|
||||
#define FORD(i,s,t) for(int i = (s);i >= (t);i--)
|
||||
#define PII pair<int,int>
|
||||
#define PB push_back
|
||||
#define MP make_pair
|
||||
#define ft first
|
||||
#define sd second
|
||||
#define lowbit(x) (x&(-x))
|
||||
#define INF (1<<30)
|
||||
int n,m;
|
||||
int C[2011][2011];
|
||||
char str[2011][2011];
|
||||
void fun(){
|
||||
C[0][0] = 0;
|
||||
FOR(i,1,n){
|
||||
C[i][0] = 0;
|
||||
FOR(j,1,m){
|
||||
C[i][j] = C[i][j-1]+(str[i][j]=='*'?1:0);
|
||||
}
|
||||
}
|
||||
FOR(i,2,n){
|
||||
FOR(j,1,m){
|
||||
C[i][j] += C[i-1][j];
|
||||
}
|
||||
}
|
||||
}
|
||||
int Area(int x1,int y1,int x2,int y2){
|
||||
if(x1>x2)swap(x1,x2);
|
||||
if(y1>y2)swap(y1,y2);
|
||||
return C[x2][y2]-C[x2][y1-1]-C[x1-1][y2]+C[x1-1][y1-1];
|
||||
}
|
||||
int main()
|
||||
{
|
||||
while(~scanf("%d%d",&n,&m),n,m){
|
||||
int x,y;
|
||||
scanf("%d%d",&x,&y);
|
||||
FOR(i,1,n)scanf("%s",str[i]+1);
|
||||
fun();
|
||||
int ans = 0;
|
||||
FOR(i,1,n){
|
||||
FOR(j,1,m){
|
||||
if(str[i][j] != '*')continue;
|
||||
int xx1 = i+x-1;
|
||||
int yy1 = j+y-1;
|
||||
if(!(xx1<1||yy1<1||xx1>n||yy1>m)){
|
||||
if(Area(i,j,xx1,yy1) == x*y)ans++;
|
||||
}
|
||||
int xx2 = i+y-1;
|
||||
int yy2 = j+x-1;
|
||||
if(xx2 == xx1 && yy2==yy1)continue;
|
||||
if(xx2<1||yy2<1||xx2>n||yy2>m)continue;
|
||||
if(Area(i,j,xx2,yy2) == x*y)ans++;
|
||||
}
|
||||
}
|
||||
printf("%d\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,137 @@
|
|||
#include <cstdlib>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
#include <iostream>
|
||||
#include <queue>
|
||||
using namespace std;
|
||||
typedef long long LL;
|
||||
const int N = 600;
|
||||
LL n;
|
||||
int bit[20];
|
||||
LL f[60];
|
||||
LL dp[15][N];
|
||||
LL POW[15];
|
||||
LL seq[60];
|
||||
LL suf[20];
|
||||
queue<int>q;
|
||||
struct Ac_Auto{
|
||||
int ch[N][10];
|
||||
int fail[N];
|
||||
bool flag[N];
|
||||
int idx, root;
|
||||
int newnd() {
|
||||
memset(ch[idx], 0, sizeof (ch[idx]));
|
||||
flag[idx] = false, fail[idx] = 0;
|
||||
return idx++;
|
||||
}
|
||||
void init() {
|
||||
idx = 0, root = newnd();
|
||||
}
|
||||
void insert(LL x) {
|
||||
int id = 0;
|
||||
while (x) bit[id++] = x%10, x/=10;
|
||||
int p = root;
|
||||
for (int i = id-1; i >= 0; --i) {
|
||||
if (!ch[p][bit[i]]) ch[p][bit[i]] = newnd();
|
||||
p = ch[p][bit[i]];
|
||||
}
|
||||
flag[p] = true;
|
||||
}
|
||||
void build() {
|
||||
for (int i = 0; i < 10; ++i) {
|
||||
if (ch[root][i]) {
|
||||
q.push(ch[root][i]);
|
||||
}
|
||||
}
|
||||
while (!q.empty()) {
|
||||
int u = q.front();
|
||||
q.pop();
|
||||
for (int i = 0; i < 10; ++i) {
|
||||
int &v = ch[u][i];
|
||||
int x = fail[u];
|
||||
if (v) {
|
||||
q.push(v);
|
||||
while (x && !ch[x][i]) x = fail[x];
|
||||
fail[v] = ch[x][i];
|
||||
flag[v] = flag[v] || flag[fail[v]];
|
||||
} else {
|
||||
v = ch[x][i];
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
void find(LL x) {
|
||||
int id = 0;
|
||||
while (x) bit[id++] = x%10, x/=10;
|
||||
int p = root;
|
||||
for (int i = id-1; i >= 0; --i) {
|
||||
p = ch[p][bit[i]];
|
||||
if (flag[p]) {
|
||||
cout << "OMG" << endl;
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
Ac_Auto ac;
|
||||
LL count(int p, int sta, bool bound) {
|
||||
if (p == 0) return 0;
|
||||
if (!bound && ~dp[p][sta]) return dp[p][sta];
|
||||
int y = bound ? bit[p] : 9;
|
||||
LL sum = 0;
|
||||
int tsta;
|
||||
for (int i = 0; i <= y; ++i) {
|
||||
tsta = ac.ch[sta][i];
|
||||
if (ac.flag[tsta]) {
|
||||
if (bound&&i==y) sum += suf[p-1]+1;
|
||||
else sum += POW[p-1];
|
||||
continue;
|
||||
}
|
||||
sum += ::count(p-1, tsta, bound&&i==y);
|
||||
}
|
||||
if (!bound) dp[p][sta] = sum;
|
||||
return sum;
|
||||
}
|
||||
LL cal(LL x) {
|
||||
int idx = 1;
|
||||
while (x) suf[idx] = suf[idx-1]+x%10*POW[idx-1], bit[idx++] = x%10, x/=10;
|
||||
return ::count(idx-1, ac.root, true);
|
||||
}
|
||||
void prepare() {
|
||||
f[1] = 1, f[2] = 1;
|
||||
for (int i = 3; i <= 55; ++i) {
|
||||
f[i] = f[i-1] + f[i-2];
|
||||
}
|
||||
ac.init();
|
||||
for (int i = 7; i <= 55; ++i) {
|
||||
ac.insert(f[i]);
|
||||
}
|
||||
ac.build();
|
||||
POW[0] = 1;
|
||||
for (int i = 1; i < 15; ++i) POW[i] = POW[i-1] * 10;
|
||||
memset(dp, 0xff, sizeof (dp));
|
||||
LL tmp;
|
||||
for (int i = 2; i <= 55; ++i) {
|
||||
LL l = 13, r = POW[12], mid;
|
||||
while (l <= r) {
|
||||
mid = (l + r) >> 1;
|
||||
if ((tmp=cal(mid)) < f[i]) l = mid + 1;
|
||||
else if (tmp > f[i]) r = mid - 1;
|
||||
else seq[i] = mid, r = mid - 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
int main() {
|
||||
prepare();
|
||||
while (cin >> n, n != -1) {
|
||||
LL ret = 1LL << 60;
|
||||
for (int i = 2; i <= 55; ++i) {
|
||||
LL t = seq[i] - n;
|
||||
if (t < 0) t = -t;
|
||||
ret = min(ret, t);
|
||||
}
|
||||
cout << ret << endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,23 @@
|
|||
#include <iostream>
|
||||
using namespace std;
|
||||
int main()
|
||||
{
|
||||
int n,k,m,t;
|
||||
cin >> t;
|
||||
while(t--)
|
||||
{
|
||||
cin >> n >> k >> m;
|
||||
if(m>n)
|
||||
cout << k<< endl;
|
||||
else
|
||||
{
|
||||
int sub = n*k;
|
||||
if(sub%m==0)
|
||||
cout << sub/m;
|
||||
else
|
||||
cout << sub/m+1;
|
||||
cout << endl;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,37 @@
|
|||
#include <stdio.h>
|
||||
#include <iostream>
|
||||
#include <string>
|
||||
#include <string.h>
|
||||
#include <algorithm>
|
||||
#include <math.h>
|
||||
using namespace std;
|
||||
double s[25],temp[25];
|
||||
int main()
|
||||
{
|
||||
int n;
|
||||
while(scanf("%d", &n) && n)
|
||||
{
|
||||
for(int i = 1; i <= n; ++i)
|
||||
{
|
||||
scanf("%lf", &s[i]);
|
||||
temp[i] = s[i];
|
||||
}
|
||||
sort(temp + 1, temp + n + 1);
|
||||
double sum = 0;
|
||||
for(int i = 2; i < n; ++i)
|
||||
sum += temp[i];
|
||||
sum /= (n - 2);
|
||||
double min = 10000000;
|
||||
int ans;
|
||||
for(int i = 1; i <= n; ++i)
|
||||
{
|
||||
if(fabs(s[i] - sum) < min)
|
||||
{
|
||||
min = fabs(s[i] - sum);
|
||||
ans = i;
|
||||
}
|
||||
}
|
||||
printf("%d\n", ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,51 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <queue>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
#define lz 2*u,l,mid
|
||||
#define rz 2*u+1,mid+1,r
|
||||
const int maxn=110000;
|
||||
int sum[2*maxn], dp[maxn+5], a[maxn+5];
|
||||
void Update(int u, int l, int r, int p, int c)
|
||||
{
|
||||
sum[u]=max(sum[u],c);
|
||||
if(l==r)return ;
|
||||
int mid=(l+r)>>1;
|
||||
if(p<=mid) Update(lz,p,c);
|
||||
else Update(rz,p,c);
|
||||
}
|
||||
int Query(int u, int l, int r, int tl, int tr)
|
||||
{
|
||||
if(tl>tr) return 0;
|
||||
if(tl<=l&&r<=tr) return sum[u];
|
||||
int mid=(l+r)>>1;
|
||||
if(tr<=mid) return Query(lz,tl,tr);
|
||||
else if(tl>mid) return Query(rz,tl,tr);
|
||||
else
|
||||
{
|
||||
int t1=Query(lz,tl,mid);
|
||||
int t2=Query(rz,mid+1,tr);
|
||||
return max(t1,t2);
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int n, d;
|
||||
while(scanf("%d%d",&n,&d)!=EOF)
|
||||
{
|
||||
memset(sum,0,sizeof(sum));
|
||||
for(int i=1; i<=n; i++)
|
||||
scanf("%d",a+i);
|
||||
int maxx=0;
|
||||
for(int i=1; i<=n; i++)
|
||||
{
|
||||
if(i>d+1) Update(1,1,maxn,a[i-d-1]+1,dp[i-d-1]);
|
||||
dp[i]=Query(1,1,maxn,1,a[i])+1;
|
||||
maxx=max(dp[i],maxx);
|
||||
}
|
||||
printf("%d\n",maxx);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,113 @@
|
|||
#include<iostream>
|
||||
#include<cstring>
|
||||
#include<algorithm>
|
||||
const int N=207;
|
||||
const int inf=1e7;
|
||||
using namespace std;
|
||||
int dist1[N];
|
||||
int dist0[N];
|
||||
int visited[N];
|
||||
int edge1[N][N];
|
||||
int edge0[N][N];
|
||||
int n,m,k;
|
||||
void Dijkstra1(int u){
|
||||
memset(visited,0,sizeof(visited));
|
||||
for(int i=1;i<=n;i++){
|
||||
dist1[i]=edge1[u][i];
|
||||
}
|
||||
visited[u]=1;
|
||||
for(int i=1;i<n;i++){
|
||||
int min=inf,v=u;
|
||||
for(int j=1;j<=n;j++){
|
||||
if(dist1[j]<min&&!visited[j]){
|
||||
min=dist1[j];
|
||||
v=j;
|
||||
}
|
||||
}
|
||||
if(min==inf)return ;
|
||||
visited[v]=1;
|
||||
for(int k=1;k<=n;k++){
|
||||
if(!visited[k]&&edge1[v][k]<inf&&dist1[v]+edge1[v][k]<dist1[k]){
|
||||
dist1[k]=dist1[v]+edge1[v][k];
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
void Dijkstra0(int u){
|
||||
memset(visited,0,sizeof(visited));
|
||||
for(int i=1;i<=n;i++){
|
||||
dist0[i]=edge0[u][i];
|
||||
}
|
||||
visited[u]=1;
|
||||
for(int i=1;i<n;i++){
|
||||
int min=inf,v=u;
|
||||
for(int j=1;j<=n;j++){
|
||||
if(dist0[j]<min&&!visited[j]){
|
||||
min=dist0[j];
|
||||
v=j;
|
||||
}
|
||||
}
|
||||
if(min==inf)return ;
|
||||
visited[v]=1;
|
||||
for(int k=1;k<=n;k++){
|
||||
if(!visited[k]&&edge0[v][k]<inf&&dist0[v]+edge0[v][k]<dist0[k]){
|
||||
dist0[k]=dist0[v]+edge0[v][k];
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
int main(){
|
||||
int _case;
|
||||
scanf("%d",&_case);
|
||||
while(_case--){
|
||||
scanf("%d%d",&n,&m);
|
||||
char str[10100];
|
||||
for(int i=1;i<=n;i++){
|
||||
for(int j=1;j<=n;j++){
|
||||
edge1[i][j]=edge1[j][i]=inf;
|
||||
edge0[i][j]=edge0[j][i]=inf;
|
||||
}
|
||||
}
|
||||
for(int i=1;i<=m;i++){
|
||||
scanf("%s%d",str,&k);
|
||||
int len=strlen(str);
|
||||
int s1=0,s2=0;
|
||||
if(k==1){
|
||||
for(int j=0;j<len;j++){
|
||||
while(str[j]!='+'&&j<len){
|
||||
s2=s2*10+str[j]-'0';
|
||||
j++;
|
||||
}
|
||||
edge1[s1][s2]=1;
|
||||
edge0[s1][s2]=1;
|
||||
s1=s2;
|
||||
s2=0;
|
||||
}
|
||||
}else if(k==0){
|
||||
for(int j=0;j<len;j++){
|
||||
while(str[j]!='+'&&j<len){
|
||||
s2=s2*10+str[j]-'0';
|
||||
j++;
|
||||
}
|
||||
edge0[s1][s2]=1;
|
||||
s1=s2;
|
||||
s2=0;
|
||||
}
|
||||
}
|
||||
}
|
||||
int d1,d2,u,v;
|
||||
scanf("%d%d%d%d",&d1,&d2,&u,&v);
|
||||
Dijkstra1(u);
|
||||
Dijkstra0(u);
|
||||
if(dist1[v]==inf&&dist0[v]==inf){
|
||||
printf("-1\n");
|
||||
}else if(dist1[v]==inf&&dist0[v]<inf){
|
||||
printf("%d\n",dist0[v]*d1);
|
||||
}else if(dist1[v]<inf&&dist0[v]==inf){
|
||||
printf("%d\n",dist1[v]*d2);
|
||||
}else {
|
||||
printf("%d\n",min(dist1[v]*d2,dist0[v]*d1));
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,58 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
char n[111],m[111],p[111],mid[111];
|
||||
int compare(char *s1,char *s2)
|
||||
{
|
||||
int len1=strlen(s1);
|
||||
int len2=strlen(s2);
|
||||
if(len1>len2) return 1;
|
||||
else if(len1<len2) return 0;
|
||||
for(int i=0;i<len1;i++)
|
||||
{
|
||||
if(s1[i]>s2[i]) return 1;
|
||||
else if(s2[i]>s1[i]) return 0;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
void solve(char *s1,char *s2)
|
||||
{
|
||||
int len=strlen(s2);
|
||||
int len1=strlen(s1);
|
||||
strrev(s1);
|
||||
strrev(s2);
|
||||
for(int i=0;i<len;i++)
|
||||
{
|
||||
s1[i]=s1[i]-'0'+s2[i]-'0'+'0';
|
||||
}
|
||||
for(int i=0;i<len1;i++)
|
||||
{
|
||||
if(s1[i]>'9')
|
||||
{
|
||||
s1[i]=s1[i]-10;
|
||||
if(i+1==len1) {s1[len1]='1';s1[len1+1]='\0';}
|
||||
else
|
||||
s1[i+1]++;
|
||||
}
|
||||
}
|
||||
strrev(s1);
|
||||
if(compare(s1,m)) printf("YES\n");
|
||||
else printf("NO\n");
|
||||
}
|
||||
int main()
|
||||
{
|
||||
while(scanf("%s %s %s",n,m,p)!=EOF)
|
||||
{
|
||||
if(strlen(m)==1&&m[0]-'0'<3) {printf("NO\n");continue;}
|
||||
if(strcmp(p,"0")==0)
|
||||
{
|
||||
if(strcmp(n,m)==0) printf("YES\n");
|
||||
else printf("NO\n");
|
||||
continue;
|
||||
}
|
||||
if(compare(n,m)) {printf("YES\n"); continue;}
|
||||
if(strlen(p)>strlen(n))
|
||||
solve(p,n);
|
||||
else solve(n,p);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,30 @@
|
|||
#include <stdio.h>
|
||||
int main()
|
||||
{
|
||||
int t;
|
||||
scanf("%d",&t);
|
||||
while(t--)
|
||||
{
|
||||
int n;
|
||||
scanf("%d",&n);
|
||||
__int64 a,t = 0;
|
||||
int flag = 1;
|
||||
while(n--)
|
||||
{
|
||||
scanf("%I64d",&a);
|
||||
if(flag)
|
||||
{
|
||||
t = a - t;
|
||||
if(t<0)
|
||||
{
|
||||
flag = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
if(flag && !t)
|
||||
printf("yeah~ I escaped ^_^\n");
|
||||
else
|
||||
printf("I will never go out T_T\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,52 @@
|
|||
#include <cmath>
|
||||
#include <cstring>
|
||||
#include <cstdio>
|
||||
#include <cstdlib>
|
||||
#include <algorithm>
|
||||
#include <iostream>
|
||||
using namespace std;
|
||||
typedef long long LL;
|
||||
const int N = 10005;
|
||||
int n;
|
||||
int seq[N];
|
||||
int k1, k2;
|
||||
LL K;
|
||||
int main() {
|
||||
int T, ca = 0;
|
||||
scanf("%d", &T);
|
||||
while (T--) {
|
||||
LL sum = 0;
|
||||
int c;
|
||||
scanf("%d %d %d %I64d", &n, &k1, &k2, &K);
|
||||
for (int i = 0; i < n; ++i) {
|
||||
scanf("%d", &c);
|
||||
sum += c;
|
||||
}
|
||||
printf("Case #%d: ", ++ca);
|
||||
if (sum > K) {
|
||||
puts("0");
|
||||
continue;
|
||||
}
|
||||
int k3 = k1 + k2;
|
||||
if (k3 >= 0) {
|
||||
if (k3 <= 1) {
|
||||
puts("inf");
|
||||
} else {
|
||||
int d = 1;
|
||||
while ((long double)1.0*sum <= (long double)1.0*K/k3) ++d, sum*=k3;
|
||||
printf("%d\n", d);
|
||||
}
|
||||
} else {
|
||||
if (k3 == -1) {
|
||||
puts("inf");
|
||||
} else {
|
||||
k3 *= -1;
|
||||
int d = 1;
|
||||
while ((long double)1.0*sum <= (long double)1.0*K/k3) ++d, sum*=k3;
|
||||
if (d & 1) printf("%d\n", d+1);
|
||||
else printf("%d\n", d);
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,62 @@
|
|||
#include <cstdlib>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
#include <iostream>
|
||||
using namespace std;
|
||||
const int MaX = 105;
|
||||
int N, K, D, S;
|
||||
struct Node {
|
||||
int ti;
|
||||
int qz;
|
||||
}seq[MaX];
|
||||
int dp[MaX][MaX];
|
||||
void solve() {
|
||||
memset(dp, 0xff, sizeof (dp));
|
||||
dp[0][N] = 0;
|
||||
for (int i = 1; i <= K; ++i) {
|
||||
const int &ti = seq[i].ti;
|
||||
const int &qz = seq[i].qz;
|
||||
for (int j = 0; j <= N; ++j) {
|
||||
if (dp[i-1][j] != -1) dp[i][j] = dp[i-1][j] + j*(ti-seq[i-1].ti);
|
||||
if (j == 0) {
|
||||
for (int k = 1; k <= qz; ++k) {
|
||||
if (k <= N && dp[i-1][k] != -1) {
|
||||
if (dp[i][0] == -1) {
|
||||
dp[i][0] = D + dp[i-1][k] + k*(ti-seq[i-1].ti);
|
||||
} else {
|
||||
dp[i][0] = min(dp[i][0], D + dp[i-1][k] + k*(ti-seq[i-1].ti));
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if ((j+qz) <= N && dp[i-1][j+qz] != -1) {
|
||||
if (dp[i][j] == -1) {
|
||||
dp[i][j] = D + dp[i-1][j+qz] + (j+qz)*(ti-seq[i-1].ti);
|
||||
} else {
|
||||
dp[i][j] = min(dp[i][j], D + dp[i-1][j+qz] + (j+qz)*(ti-seq[i-1].ti));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
printf("%d\n", dp[K][0]);
|
||||
}
|
||||
int main() {
|
||||
int T;
|
||||
scanf("%d", &T);
|
||||
while (T--) {
|
||||
scanf("%d %d %d %d", &N, &K, &D, &S);
|
||||
int sum = 0;
|
||||
for (int i = 1; i <= K; ++i) {
|
||||
scanf("%d %d", &seq[i].ti, &seq[i].qz);
|
||||
sum += seq[i].qz;
|
||||
}
|
||||
if (sum < N) {
|
||||
puts("impossible");
|
||||
continue;
|
||||
}
|
||||
solve();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,83 @@
|
|||
#include<cstdio>
|
||||
#include<cmath>
|
||||
#include<cstring>
|
||||
#include<iostream>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
typedef long long int64;
|
||||
const int INF = 0x3f3f3f3f;
|
||||
const int MAXN = 10010;
|
||||
int m;
|
||||
int mat[8][8];
|
||||
int blast[8][8];
|
||||
const int dir[][2] = {{-1,0},{1,0},{0,-1},{0,1}};
|
||||
struct Node{
|
||||
int x, y;
|
||||
int cnt;
|
||||
int dir;
|
||||
}Q[500000];
|
||||
void addQue(int x, int y, int cnt, int& rear){
|
||||
mat[x][y] = 0;
|
||||
for(int i=0; i<4; ++i){
|
||||
int dx = x + dir[i][0];
|
||||
int dy = y + dir[i][1];
|
||||
if(dx>=1&&dx<=6&&dy>=1&&dy<=6){
|
||||
Q[rear].x = dx;
|
||||
Q[rear].y = dy;
|
||||
Q[rear].cnt = cnt;
|
||||
Q[rear++].dir = i;
|
||||
}
|
||||
}
|
||||
}
|
||||
void bfs(int x, int y){
|
||||
int front=0, rear=0;
|
||||
addQue(x, y, 0, rear);
|
||||
int cur = 0;
|
||||
while(front < rear){
|
||||
while(front < rear && Q[front].cnt==cur){
|
||||
Node &t = Q[front++];
|
||||
if(mat[t.x][t.y]){
|
||||
++mat[t.x][t.y];
|
||||
} else{
|
||||
Node& now = Q[rear];
|
||||
now.x = t.x + dir[t.dir][0];
|
||||
now.y = t.y + dir[t.dir][1];
|
||||
now.cnt = t.cnt + 1;
|
||||
now.dir = t.dir;
|
||||
if(now.x>=1&&now.x<=6&&now.y>=1&&now.y<=6)
|
||||
++rear;
|
||||
}
|
||||
}
|
||||
for(int i=1; i<=6; ++i){
|
||||
for(int j=1; j<=6; ++j)if(mat[i][j]>4){
|
||||
addQue(i,j,cur+1,rear);
|
||||
}
|
||||
}
|
||||
++cur;
|
||||
}
|
||||
}
|
||||
int main(){
|
||||
int x, y;
|
||||
while(~scanf("%d", &mat[1][1])){
|
||||
for(int i=1; i<=6; ++i){
|
||||
for(int j=(i==1?2:1); j<=6; ++j){
|
||||
scanf("%d", &mat[i][j]);
|
||||
}
|
||||
}
|
||||
scanf("%d", &m);
|
||||
for(int i=0; i<m; ++i){
|
||||
scanf("%d%d", &x, &y);
|
||||
if(++mat[x][y]>4){
|
||||
bfs(x, y);
|
||||
}
|
||||
}
|
||||
for(int i=1; i<=6; ++i){
|
||||
for(int j=1; j<=6; ++j)
|
||||
if(j!=1) printf(" %d", mat[i][j]);
|
||||
else printf("%d", mat[i][j]);
|
||||
putchar('\n');
|
||||
}
|
||||
putchar('\n');
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,96 @@
|
|||
#include<iostream>
|
||||
#include<algorithm>
|
||||
#include<queue>
|
||||
#include<stdio.h>
|
||||
#include<stdlib.h>
|
||||
#include<string.h>
|
||||
using namespace std;
|
||||
const int N = 100 + 10;
|
||||
char g[N][N];
|
||||
int n, m, t;
|
||||
int sx, sy, dx, dy, ex, ey;
|
||||
bool vis[N][N][4];
|
||||
int dir[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
|
||||
struct node
|
||||
{
|
||||
int x, y, step;
|
||||
int state;
|
||||
node(){}
|
||||
node(int xx, int yy, int st):x(xx), y(yy), step(st){ state = 0;}
|
||||
};
|
||||
int BFS()
|
||||
{
|
||||
memset(vis, false, sizeof(vis));
|
||||
queue<node> Q;
|
||||
Q.push(node(sx, sy, 0));
|
||||
vis[sx][sy][0] = true;
|
||||
while(!Q.empty())
|
||||
{
|
||||
node cur = Q.front();
|
||||
Q.pop();
|
||||
if(cur.step > t) return -1;
|
||||
for(int k = 0; k < 4; ++k)
|
||||
{
|
||||
int x = cur.x + dir[k][0], y = cur.y + dir[k][1];
|
||||
if(x < 0 || x >= n || y < 0 || y >= m) continue;
|
||||
bool flag = false;
|
||||
if(!(cur.state & 1) && (dx == cur.x || dy == cur.y)) flag = true;
|
||||
if(!(cur.state & 2) && (ex == cur.x || ey == cur.y)) flag = true;
|
||||
if(!flag) continue;
|
||||
while(true)
|
||||
{
|
||||
if(g[x][y] == 'X') break;
|
||||
if(g[x][y] == 'D') {
|
||||
cur.state |= 1;
|
||||
break;
|
||||
}
|
||||
if(g[x][y] == 'E') {
|
||||
cur.state |= 2;
|
||||
break;
|
||||
}
|
||||
x += dir[k][0], y += dir[k][1];
|
||||
if(x < 0 || x >= n || y < 0 || y >= m) break;
|
||||
}
|
||||
}
|
||||
if(cur.state == 3) {
|
||||
return cur.step;
|
||||
}
|
||||
for(int k = 0; k < 4; ++k)
|
||||
{
|
||||
int x = cur.x + dir[k][0], y = cur.y + dir[k][1];
|
||||
if(x < 0 || x >= n || y < 0 || y >= m || vis[x][y][cur.state] || g[x][y] == 'X') continue;
|
||||
if(g[x][y] == 'D' || g[x][y] == 'E') continue;
|
||||
vis[x][y][cur.state] = true;
|
||||
node tmp = node(x, y, cur.step + 1);
|
||||
tmp.state = cur.state;
|
||||
Q.push(tmp);
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int T, cas = 0;
|
||||
scanf("%d",&T);
|
||||
while(T--)
|
||||
{
|
||||
scanf("%d %d %d",&n, &m, &t);
|
||||
for(int i = 0; i < n; ++i)
|
||||
{
|
||||
scanf("%s",g[i]);
|
||||
for(int j = 0; j < m; ++j)
|
||||
{
|
||||
if(g[i][j] == 'S')
|
||||
sx = i, sy = j;
|
||||
if(g[i][j] == 'E')
|
||||
ex = i, ey = j;
|
||||
if(g[i][j] == 'D')
|
||||
dx = i, dy = j;
|
||||
}
|
||||
}
|
||||
g[sx][sy] = '.';
|
||||
int ans = BFS();
|
||||
printf("Case %d:\n%d\n", ++cas, ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,95 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
int t,N;
|
||||
char s[10][10];
|
||||
bool suit[10][1<<8+5];
|
||||
int dp[8][11][1<<8][1<<8];
|
||||
int one[1<<8+5];
|
||||
inline void init()
|
||||
{
|
||||
memset(suit,0,sizeof(suit));
|
||||
for(int i=0;i<8;i++)
|
||||
{
|
||||
for(int j=0;j< 1<<8;j++)
|
||||
{
|
||||
int tag=1;
|
||||
for(int k=0;k<8;k++)
|
||||
{
|
||||
if(s[i][k]=='*'&&(j&(1<<k)))
|
||||
{
|
||||
tag=0;break;
|
||||
}
|
||||
}
|
||||
if(tag) suit[i][j]=1;
|
||||
}
|
||||
}
|
||||
}
|
||||
inline int getOne(int i)
|
||||
{
|
||||
int ans=0;
|
||||
while(i)
|
||||
{
|
||||
ans+=i%2;
|
||||
i/=2;
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
for(int i=0;i< 1<<8;i++)
|
||||
{
|
||||
one[i]=getOne(i);
|
||||
}
|
||||
scanf("%d",&t);
|
||||
while(t--)
|
||||
{
|
||||
scanf("%d",&N);
|
||||
for(int i=0;i<8;i++) scanf("%s",s[i]);
|
||||
init();
|
||||
memset(dp,0,sizeof(dp));
|
||||
for(int i=0;i< 1<<8;i++)
|
||||
{
|
||||
if(suit[0][i]&&one[i]<=N)
|
||||
{
|
||||
dp[0][one[i]][i][0]=1;
|
||||
}
|
||||
}
|
||||
for(int i=1;i<8;i++)
|
||||
for(int n=0;n<=N;n++)
|
||||
for(int j=0;j< 1<<8;j++)
|
||||
{
|
||||
if(one[j]>n) continue;
|
||||
if(!suit[i][j]) continue;
|
||||
for(int k=0;k< 1<<8;k++)
|
||||
{
|
||||
if(one[k]+one[j]>n) continue;
|
||||
if(k&(j<<2)) continue;
|
||||
if(k&(j>>2)) continue;
|
||||
for(int r=0;r< 1<<8;r++)
|
||||
{
|
||||
if(one[k]+one[j]+one[r]>n) continue;
|
||||
if(r&(j<<1)) continue;
|
||||
if(r&(j>>1)) continue;
|
||||
dp[i][n][j][k]+=dp[i-1][n-one[j]][k][r];
|
||||
}
|
||||
}
|
||||
}
|
||||
int ans=0;
|
||||
for(int i=0;i< 1<<8;i++)
|
||||
{
|
||||
if(suit[7][i])
|
||||
{
|
||||
for(int j=0;j< 1<<8;j++)
|
||||
{
|
||||
if(suit[6][j])
|
||||
{
|
||||
ans+=dp[7][N][i][j];
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
printf("%d\n",ans);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,26 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
int main()
|
||||
{
|
||||
int t,q,a,b,i;
|
||||
double x,ans;
|
||||
scanf("%d",&t);
|
||||
while(t--)
|
||||
{
|
||||
scanf("%lf%d",&x,&q);
|
||||
for(i = 1; i<=q; i++)
|
||||
{
|
||||
scanf("%d%d",&a,&b);
|
||||
if(a == 1)
|
||||
ans = b*60.0-b*x;
|
||||
else if(a == 2)
|
||||
ans = b*3600.0/(60.0-x);
|
||||
else if(a == 3)
|
||||
ans = 43200*b*60/x;
|
||||
printf("%.2lf\n",ans);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,328 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <algorithm>
|
||||
#include <map>
|
||||
#include <set>
|
||||
#include <string>
|
||||
#include <queue>
|
||||
#include <iostream>
|
||||
using namespace std;
|
||||
char str[3][3][6];
|
||||
char g[3][3][6];
|
||||
map<int,int>mp;
|
||||
queue<int>q;
|
||||
bool mo[6];
|
||||
int F[50];
|
||||
int find(int x)
|
||||
{
|
||||
if(F[x]==-1)return x;
|
||||
return F[x]=find(F[x]);
|
||||
}
|
||||
void bing(int x,int y)
|
||||
{
|
||||
int t1=find(x);
|
||||
int t2=find(y);
|
||||
if(t1!=t2)F[t1]=t2;
|
||||
}
|
||||
bool judge(int state)
|
||||
{
|
||||
char temp[10];
|
||||
int t[10];
|
||||
sprintf(temp,"%09d",state);
|
||||
for(int i=0;i<9;i++)t[i]=temp[i]-'0';
|
||||
for(int i=0;i<3;i++)
|
||||
for(int j=0;j<3;j++)
|
||||
{
|
||||
int p=t[3*i+j];
|
||||
int x=p/3;
|
||||
int y=p%3;
|
||||
strcpy(g[i][j],str[x][y]);
|
||||
}
|
||||
memset(F,-1,sizeof(F));
|
||||
for(int i=0;i<3;i++)
|
||||
for(int j=0;j<3;j++)
|
||||
{
|
||||
if(g[i][j][0]==g[i][j][2])bing(12*i+4*j,12*i+4*j+2);
|
||||
if(g[i][j][0]==g[i][j][3])bing(12*i+4*j,12*i+4*j+3);
|
||||
if(g[i][j][1]==g[i][j][2])bing(12*i+4*j+1,12*i+4*j+2);
|
||||
if(g[i][j][1]==g[i][j][3])bing(12*i+4*j+1,12*i+4*j+3);
|
||||
}
|
||||
for(int i=0;i<3;i++)
|
||||
{
|
||||
if(g[i][0][3]==g[i][1][2])bing(12*i+3,12*i+4+2);
|
||||
if(g[i][1][3]==g[i][2][2])bing(12*i+4+3,12*i+8+2);
|
||||
}
|
||||
for(int j=0;j<3;j++)
|
||||
{
|
||||
if(g[0][j][1]==g[1][j][0])bing(4*j+1,12+4*j+0);
|
||||
if(g[1][j][1]==g[2][j][0])bing(12+4*j+1,24+4*j+0);
|
||||
}
|
||||
int R=-1,G=-1,B=-1,O=-1;
|
||||
for(int i=0;i<3;i++)
|
||||
for(int j=0;j<3;j++)
|
||||
for(int k=0;k<4;k++)
|
||||
{
|
||||
int t1=find(12*i+4*j+k);
|
||||
if(g[i][j][k]=='R')
|
||||
{
|
||||
if(R==-1)R=t1;
|
||||
else if(t1!=R)return false;
|
||||
}
|
||||
else if(g[i][j][k]=='G')
|
||||
{
|
||||
if(G==-1)G=t1;
|
||||
else if(t1!=G)return false;
|
||||
}
|
||||
else if(g[i][j][k]=='B')
|
||||
{
|
||||
if(B==-1)B=t1;
|
||||
else if(t1!=B)return false;
|
||||
}
|
||||
else
|
||||
{
|
||||
if(O==-1)O=t1;
|
||||
else if(t1!=O)return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
int bfs()
|
||||
{
|
||||
mp.clear();
|
||||
while(!q.empty())q.pop();
|
||||
int tmp,now;
|
||||
char ss1[10],ss2[10];
|
||||
tmp=12345678;
|
||||
mp[tmp]=0;
|
||||
q.push(tmp);
|
||||
while(!q.empty())
|
||||
{
|
||||
tmp=q.front();
|
||||
q.pop();
|
||||
if(judge(tmp))return mp[tmp];
|
||||
sprintf(ss1,"%09d",tmp);
|
||||
for(int i=0;i<3;i++)
|
||||
for(int j=0;j<3;j++)
|
||||
{
|
||||
int t=ss1[3*i+j]-'0';
|
||||
strcpy(g[i][j],str[t/3][t%3]);
|
||||
}
|
||||
if(mo[0])
|
||||
{
|
||||
strcpy(ss2,ss1);
|
||||
ss2[0]=ss1[1];
|
||||
ss2[1]=ss1[2];
|
||||
ss2[2]=ss1[0];
|
||||
now=0;
|
||||
for(int i=0;i<9;i++)
|
||||
{
|
||||
now*=10;
|
||||
now+=ss2[i]-'0';
|
||||
}
|
||||
if(mp.find(now)==mp.end())
|
||||
{
|
||||
mp[now]=mp[tmp]+1;
|
||||
q.push(now);
|
||||
}
|
||||
ss2[0]=ss1[2];
|
||||
ss2[1]=ss1[0];
|
||||
ss2[2]=ss1[1];
|
||||
now=0;
|
||||
for(int i=0;i<9;i++)
|
||||
{
|
||||
now*=10;
|
||||
now+=ss2[i]-'0';
|
||||
}
|
||||
if(mp.find(now)==mp.end())
|
||||
{
|
||||
mp[now]=mp[tmp]+1;
|
||||
q.push(now);
|
||||
}
|
||||
}
|
||||
if(mo[1])
|
||||
{
|
||||
strcpy(ss2,ss1);
|
||||
ss2[3]=ss1[4];
|
||||
ss2[4]=ss1[5];
|
||||
ss2[5]=ss1[3];
|
||||
now=0;
|
||||
for(int i=0;i<9;i++)
|
||||
{
|
||||
now*=10;
|
||||
now+=ss2[i]-'0';
|
||||
}
|
||||
if(mp.find(now)==mp.end())
|
||||
{
|
||||
mp[now]=mp[tmp]+1;
|
||||
q.push(now);
|
||||
}
|
||||
ss2[3]=ss1[5];
|
||||
ss2[4]=ss1[3];
|
||||
ss2[5]=ss1[4];
|
||||
now=0;
|
||||
for(int i=0;i<9;i++)
|
||||
{
|
||||
now*=10;
|
||||
now+=ss2[i]-'0';
|
||||
}
|
||||
if(mp.find(now)==mp.end())
|
||||
{
|
||||
mp[now]=mp[tmp]+1;
|
||||
q.push(now);
|
||||
}
|
||||
}
|
||||
if(mo[2])
|
||||
{
|
||||
strcpy(ss2,ss1);
|
||||
ss2[6]=ss1[7];
|
||||
ss2[7]=ss1[8];
|
||||
ss2[8]=ss1[6];
|
||||
now=0;
|
||||
for(int i=0;i<9;i++)
|
||||
{
|
||||
now*=10;
|
||||
now+=ss2[i]-'0';
|
||||
}
|
||||
if(mp.find(now)==mp.end())
|
||||
{
|
||||
mp[now]=mp[tmp]+1;
|
||||
q.push(now);
|
||||
}
|
||||
ss2[6]=ss1[8];
|
||||
ss2[7]=ss1[6];
|
||||
ss2[8]=ss1[7];
|
||||
now=0;
|
||||
for(int i=0;i<9;i++)
|
||||
{
|
||||
now*=10;
|
||||
now+=ss2[i]-'0';
|
||||
}
|
||||
if(mp.find(now)==mp.end())
|
||||
{
|
||||
mp[now]=mp[tmp]+1;
|
||||
q.push(now);
|
||||
}
|
||||
}
|
||||
if(mo[3])
|
||||
{
|
||||
strcpy(ss2,ss1);
|
||||
ss2[0]=ss1[3];
|
||||
ss2[3]=ss1[6];
|
||||
ss2[6]=ss1[0];
|
||||
now=0;
|
||||
for(int i=0;i<9;i++)
|
||||
{
|
||||
now*=10;
|
||||
now+=ss2[i]-'0';
|
||||
}
|
||||
if(mp.find(now)==mp.end())
|
||||
{
|
||||
mp[now]=mp[tmp]+1;
|
||||
q.push(now);
|
||||
}
|
||||
ss2[0]=ss1[6];
|
||||
ss2[3]=ss1[0];
|
||||
ss2[6]=ss1[3];
|
||||
now=0;
|
||||
for(int i=0;i<9;i++)
|
||||
{
|
||||
now*=10;
|
||||
now+=ss2[i]-'0';
|
||||
}
|
||||
if(mp.find(now)==mp.end())
|
||||
{
|
||||
mp[now]=mp[tmp]+1;
|
||||
q.push(now);
|
||||
}
|
||||
}
|
||||
if(mo[4])
|
||||
{
|
||||
strcpy(ss2,ss1);
|
||||
ss2[1]=ss1[4];
|
||||
ss2[4]=ss1[7];
|
||||
ss2[7]=ss1[1];
|
||||
now=0;
|
||||
for(int i=0;i<9;i++)
|
||||
{
|
||||
now*=10;
|
||||
now+=ss2[i]-'0';
|
||||
}
|
||||
if(mp.find(now)==mp.end())
|
||||
{
|
||||
mp[now]=mp[tmp]+1;
|
||||
q.push(now);
|
||||
}
|
||||
ss2[1]=ss1[7];
|
||||
ss2[4]=ss1[1];
|
||||
ss2[7]=ss1[4];
|
||||
now=0;
|
||||
for(int i=0;i<9;i++)
|
||||
{
|
||||
now*=10;
|
||||
now+=ss2[i]-'0';
|
||||
}
|
||||
if(mp.find(now)==mp.end())
|
||||
{
|
||||
mp[now]=mp[tmp]+1;
|
||||
q.push(now);
|
||||
}
|
||||
}
|
||||
if(mo[5])
|
||||
{
|
||||
strcpy(ss2,ss1);
|
||||
ss2[2]=ss1[5];
|
||||
ss2[5]=ss1[8];
|
||||
ss2[8]=ss1[2];
|
||||
now=0;
|
||||
for(int i=0;i<9;i++)
|
||||
{
|
||||
now*=10;
|
||||
now+=ss2[i]-'0';
|
||||
}
|
||||
if(mp.find(now)==mp.end())
|
||||
{
|
||||
mp[now]=mp[tmp]+1;
|
||||
q.push(now);
|
||||
}
|
||||
ss2[2]=ss1[8];
|
||||
ss2[5]=ss1[2];
|
||||
ss2[8]=ss1[5];
|
||||
now=0;
|
||||
for(int i=0;i<9;i++)
|
||||
{
|
||||
now*=10;
|
||||
now+=ss2[i]-'0';
|
||||
}
|
||||
if(mp.find(now)==mp.end())
|
||||
{
|
||||
mp[now]=mp[tmp]+1;
|
||||
q.push(now);
|
||||
}
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int T;
|
||||
scanf("%d",&T);
|
||||
int iCase=0;
|
||||
while(T--)
|
||||
{
|
||||
iCase++;
|
||||
printf("Case #%d: ",iCase);
|
||||
for(int i=0;i<6;i++)mo[i]=true;
|
||||
for(int i=0;i<3;i++)
|
||||
for(int j=0;j<3;j++)
|
||||
{
|
||||
scanf("%s",&str[i][j]);
|
||||
if(str[i][j][4]=='1')
|
||||
{
|
||||
mo[i]=false;
|
||||
mo[3+j]=false;
|
||||
}
|
||||
}
|
||||
printf("%d\n",bfs());
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,47 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cstring>
|
||||
using namespace std;
|
||||
const int mod=1000000007;
|
||||
long long dp[50][520];
|
||||
long long C[520][520];
|
||||
long long A[520];
|
||||
int a[50];
|
||||
void Init(){
|
||||
C[0][0]=1;
|
||||
for(int i=1;i<480;i++){
|
||||
C[i][0]=1;
|
||||
for(int j=1;j<i;j++)
|
||||
C[i][j]=(C[i-1][j-1]+C[i-1][j])%mod;
|
||||
C[i][i]=1;
|
||||
}
|
||||
A[0]=A[1]=1;
|
||||
for(int i=2;i<480;i++)
|
||||
A[i]=(A[i-1]*i)%mod;
|
||||
}
|
||||
int main(){
|
||||
Init();
|
||||
int t,n,cases=0;
|
||||
scanf("%d",&t);
|
||||
while(t--){
|
||||
scanf("%d",&n);
|
||||
for(int i=1;i<=n;i++)
|
||||
scanf("%d",&a[i]);
|
||||
memset(dp,0,sizeof(dp));
|
||||
dp[1][a[1]-1]=1;
|
||||
long long sum=a[1];
|
||||
for(int i=2;i<=n;i++){
|
||||
for(int j=0;j<sum;j++)
|
||||
for(int k=1;k<=a[i];k++)
|
||||
for(int u=0;u<=j && u<=k;u++)
|
||||
dp[i][j-u+a[i]-1-(k-1)]=(dp[i][j-u+a[i]-k]+(((dp[i-1][j]*C[j][u])%mod*C[sum+1-j][k-u])%mod*C[a[i]-1][k-1])%mod)%mod;
|
||||
sum+=a[i];
|
||||
}
|
||||
printf("Case %d: ",++cases);
|
||||
long long ans=dp[n][0];
|
||||
for(int i=1;i<=n;i++)
|
||||
ans=(ans*A[a[i]])%mod;
|
||||
cout<<ans<<endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,62 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
const int v = 200005;
|
||||
int T, N, x;
|
||||
__int64 a, b, c, A[v], B[v], C[v];
|
||||
void f(int s, int t) {
|
||||
A[s] += a;
|
||||
B[s] += b;
|
||||
C[s] += c;
|
||||
A[t + 1] += -a;
|
||||
B[t + 1] += -b;
|
||||
C[t + 1] += -c;
|
||||
}
|
||||
void insert(__int64 x1, __int64 y1, __int64 x2, __int64 y2) {
|
||||
int m = x1 > y1 ? x1 : y1, t = x2 > y2 ? x2 : y2, t2 = x2 > y2 ? y2 : x2;
|
||||
a = b = c = 0;
|
||||
c = (x2 - x1) * (y2 - y1);
|
||||
f(t + 1, v - 5);
|
||||
a = 1;
|
||||
b = -(x1 + y1);
|
||||
c = x1 * y1;
|
||||
if(t2 >= m)
|
||||
f(m + 1, t2);
|
||||
else
|
||||
t2 = m;
|
||||
if(y2 > x2) {
|
||||
a -= 1;
|
||||
b += x2 + y1;
|
||||
c -= x2 * y1;
|
||||
}
|
||||
else if(x2 > y2) {
|
||||
a -= 1;
|
||||
b += x1 + y2;
|
||||
c -= x1 * y2;
|
||||
}
|
||||
f(t2 + 1, t);
|
||||
}
|
||||
int main() {
|
||||
scanf("%d", &T);
|
||||
while(T--) {
|
||||
memset(A, 0, sizeof(A));
|
||||
memset(B, 0, sizeof(B));
|
||||
memset(C, 0, sizeof(C));
|
||||
scanf("%d", &N);
|
||||
for(int i = 0; i < N; ++i) {
|
||||
__int64 x1, y1, x2, y2;
|
||||
scanf("%I64d%I64d%I64d%I64d", &x1, &y1, &x2, &y2);
|
||||
insert(x1, y1, x2, y2);
|
||||
}
|
||||
for(int i = 1; i < v; ++i) {
|
||||
A[i] += A[i-1];
|
||||
B[i] += B[i-1];
|
||||
C[i] += C[i-1];
|
||||
}
|
||||
scanf("%d", &x);
|
||||
while(x--) {
|
||||
__int64 t;
|
||||
scanf("%I64d", &t);
|
||||
printf("%I64d\n", t * t * A[t] + t * B[t] + C[t]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,144 @@
|
|||
#include <cstdlib>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
#include <queue>
|
||||
using namespace std;
|
||||
const int N = 1605;
|
||||
const int inf = 0x3f3f3f3f;
|
||||
int n;
|
||||
int sz;
|
||||
char str[105];
|
||||
int del[2][N][1<<8];
|
||||
int sco[2][N][1<<8];
|
||||
struct Ac_auto {
|
||||
int ch[N][26];
|
||||
int fail[N];
|
||||
int sta[N];
|
||||
int gain[N];
|
||||
char kill[N];
|
||||
int idx, root;
|
||||
int newnd() {
|
||||
memset(ch[idx], 0, sizeof (ch[idx]));
|
||||
gain[idx] = sta[idx] = fail[idx] = kill[idx] = 0;
|
||||
return idx++;
|
||||
}
|
||||
void init() {
|
||||
idx = 0, root = newnd();
|
||||
}
|
||||
void insert(char ss[], int val) {
|
||||
int len = strlen(ss);
|
||||
int p = root;
|
||||
for (int i = 0; i < len; ++i) {
|
||||
char c = ss[i]-'a';
|
||||
if (!ch[p][c]) ch[p][c] = newnd();
|
||||
p = ch[p][c];
|
||||
}
|
||||
if (val == 999) sta[p] = 1 << sz;
|
||||
else if (val == -999) kill[p] = 1;
|
||||
else gain[p] = val;
|
||||
}
|
||||
void build() {
|
||||
queue<int>q;
|
||||
for (int i = 0; i < 26; ++i) {
|
||||
if (ch[root][i]) {
|
||||
q.push(ch[root][i]);
|
||||
}
|
||||
}
|
||||
while (!q.empty()) {
|
||||
int p = q.front();
|
||||
q.pop();
|
||||
for (int i = 0; i < 26; ++i) {
|
||||
int v = ch[p][i];
|
||||
int x = fail[p];
|
||||
if (v) {
|
||||
q.push(v);
|
||||
while (x && !ch[x][i]) x = fail[x];
|
||||
fail[v] = ch[x][i];
|
||||
kill[v] |= kill[fail[v]];
|
||||
sta[v] |= sta[fail[v]];
|
||||
gain[v] += gain[fail[v]];
|
||||
} else {
|
||||
ch[p][i] = ch[x][i];
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
Ac_auto ac;
|
||||
void solve() {
|
||||
memset(del, 0x3f, sizeof (del));
|
||||
memset(sco, 0x80, sizeof (sco));
|
||||
int cur = 0, nxt = 1;
|
||||
del[cur][0][0] = 0;
|
||||
sco[cur][0][0] = 0;
|
||||
int len = strlen(str);
|
||||
int lim = 1 << sz;
|
||||
const int &idx = ac.idx;
|
||||
for (int i = 0; i < len; ++i) {
|
||||
int c = str[i]-'a';
|
||||
memset(del[nxt], 0x3f, sizeof (del[nxt]));
|
||||
memset(sco[nxt], 0x80, sizeof (sco[nxt]));
|
||||
for (int j = 0; j < idx; ++j) {
|
||||
for (int k = 0; k < lim; ++k) {
|
||||
if (del[cur][j][k] == inf) continue;
|
||||
if (del[nxt][j][k] > del[cur][j][k] + 1) {
|
||||
del[nxt][j][k] = del[cur][j][k] + 1;
|
||||
sco[nxt][j][k] = sco[cur][j][k];
|
||||
} else if (del[nxt][j][k] == del[cur][j][k] + 1) {
|
||||
if (sco[nxt][j][k] < sco[cur][j][k]) {
|
||||
sco[nxt][j][k] = sco[cur][j][k];
|
||||
}
|
||||
}
|
||||
int np = ac.ch[j][c];
|
||||
if (ac.kill[np]) continue;
|
||||
int gain = ac.gain[np];
|
||||
int nsta = k|ac.sta[np];
|
||||
if (del[nxt][np][nsta] > del[cur][j][k]) {
|
||||
del[nxt][np][nsta] = del[cur][j][k];
|
||||
sco[nxt][np][nsta] = sco[cur][j][k] + gain;
|
||||
} else if (del[nxt][np][nsta] == del[cur][j][k]) {
|
||||
if (sco[nxt][np][nsta] < sco[cur][j][k] + gain) {
|
||||
sco[nxt][np][nsta] = sco[cur][j][k] + gain;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
swap(cur, nxt);
|
||||
}
|
||||
int xdel = inf, xsco;
|
||||
for (int i = 0; i < idx; ++i) {
|
||||
if (xdel > del[cur][i][lim-1]) {
|
||||
xdel = del[cur][i][lim-1];
|
||||
xsco = sco[cur][i][lim-1];
|
||||
} else if (xdel == del[cur][i][lim-1]) {
|
||||
xsco = max(xsco, sco[cur][i][lim-1]);
|
||||
}
|
||||
}
|
||||
if (xdel == inf) {
|
||||
puts("Banned");
|
||||
} else {
|
||||
printf("%d %d\n", xdel, xsco);
|
||||
}
|
||||
}
|
||||
int main() {
|
||||
int T, ca = 0;
|
||||
scanf("%d", &T);
|
||||
while (T--) {
|
||||
int val;
|
||||
sz = 0;
|
||||
ac.init();
|
||||
scanf("%d", &n);
|
||||
for (int i = 0; i < n; ++i) {
|
||||
scanf("%s %d", str, &val);
|
||||
ac.insert(str, val);
|
||||
if (val == 999) ++sz;
|
||||
}
|
||||
ac.build();
|
||||
scanf("%s", str);
|
||||
printf("Case %d: ", ++ca);
|
||||
solve();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,26 @@
|
|||
#include <iostream>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <math.h>
|
||||
#include <vector>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
#define MAXN (100+10)
|
||||
__int64 f[MAXN]={0,0,1};
|
||||
__int64 h = 1000000007;
|
||||
int main()
|
||||
{
|
||||
int t;
|
||||
int n;
|
||||
for (int i=3;i<=100;i++)
|
||||
{
|
||||
f[i]=((i-1)*f[i-1]%h+f[i-2]*(i-1)%h)%h;
|
||||
}
|
||||
scanf(" %d",&t);
|
||||
while (t--)
|
||||
{
|
||||
scanf(" %d",&n);
|
||||
printf("%I64d\n",f[n]);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,67 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <vector>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
const int maxn = 20;
|
||||
int p[maxn], nervous[maxn], n, m, k, max_cnt;
|
||||
int att[110][3];
|
||||
void dfs(int cn) {
|
||||
if(max_cnt >= k) return ;
|
||||
if(cn >= k) {
|
||||
max_cnt = k; return ;
|
||||
}
|
||||
int a[3], bak[3];
|
||||
for(int v=0; v<3; v++) {
|
||||
a[0] = att[cn][v];
|
||||
a[1] = att[cn][(v+1)%3];
|
||||
a[2] = att[cn][(v+2)%3];
|
||||
bak[0] = nervous[a[0]];
|
||||
bak[1] = nervous[a[1]];
|
||||
bak[2] = nervous[a[2]];
|
||||
nervous[a[0]] -= 2;
|
||||
if(nervous[a[0]] < 1) nervous[a[0]] = 1;
|
||||
nervous[a[1]] += 2;
|
||||
nervous[a[2]] += 2;
|
||||
for(int i=0; i<n; i++) {
|
||||
if(p[i] == p[a[1]] && i != a[1]) nervous[i]++;
|
||||
if(p[i] == p[a[2]] && i != a[2]) nervous[i]++;
|
||||
}
|
||||
int flag = true;
|
||||
for(int i=0; i<n; i++) {
|
||||
if(nervous[i] > 5) {
|
||||
max_cnt = max(max_cnt, cn);
|
||||
flag = false;
|
||||
}
|
||||
}
|
||||
if(flag) dfs(cn+1);
|
||||
for(int i=0; i<n; i++) {
|
||||
if(p[i] == p[a[1]] && i != a[1]) nervous[i]--;
|
||||
if(p[i] == p[a[2]] && i != a[2]) nervous[i]--;
|
||||
}
|
||||
nervous[a[0]] = bak[0];
|
||||
nervous[a[1]] = bak[1];
|
||||
nervous[a[2]] = bak[2];
|
||||
}
|
||||
}
|
||||
int main(){
|
||||
int T;
|
||||
scanf("%d", &T);
|
||||
for(int kase=1; kase<=T; kase++) {
|
||||
scanf("%d%d%d", &n, &m, &k);
|
||||
for(int i=0; i<n; i++) {
|
||||
scanf("%d", &p[i]);
|
||||
}
|
||||
for(int i=0; i<n; i++) {
|
||||
scanf("%d", &nervous[i]);
|
||||
}
|
||||
for(int i=0; i<k; i++) {
|
||||
scanf("%d %d %d", &att[i][0], &att[i][1], &att[i][2]);
|
||||
}
|
||||
max_cnt = 0;
|
||||
printf("Case #%d: ", kase);
|
||||
dfs(0);
|
||||
printf("%d\n", max_cnt);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,15 @@
|
|||
This is a line with example text
|
||||
<----<--<-<----<----<-------<---
|
||||
b b b b b b b
|
||||
This is a line with example text
|
||||
<--<--<-<----<----<-------<-----
|
||||
ge ge ge ge ge ge ge
|
||||
This is a line with example text
|
||||
----->-->->---->---->------->-->
|
||||
w w w w w w w
|
||||
This is a line with example text
|
||||
--->-->->---->---->------->---->
|
||||
e e e e e e e
|
||||
while ((((true)))) printf("Hello VIM!")
|
||||
------>--->--->---->------------->-->->
|
||||
w w w w W w w
|
||||
|
|
@ -0,0 +1,109 @@
|
|||
#include <cstdlib>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
#include <iostream>
|
||||
using namespace std;
|
||||
int N, M, idx;
|
||||
int sta[175], num[175];
|
||||
int cnt[15], mp[105];
|
||||
int f[105][175][175];
|
||||
void print(int x) {
|
||||
int rec[50] = {0}, p = 0;
|
||||
while (x) {
|
||||
rec[p++] = x % 2;
|
||||
x /= 2;
|
||||
}
|
||||
for (int i = 9; i >= 0; --i) {
|
||||
printf(i == 0 ? "%d\n" : "%d", rec[i]);
|
||||
}
|
||||
}
|
||||
inline bool legal(int x) {
|
||||
if (x & (x << 2)) return false;
|
||||
return true;
|
||||
}
|
||||
void init() {
|
||||
int lim;
|
||||
idx = 1;
|
||||
for (int k = 1; k <= 10; ++k) {
|
||||
lim = 1 << k;
|
||||
for (int i = 1<<(k-1); i < lim; ++i) {
|
||||
if (legal(i)) {
|
||||
sta[idx] = i;
|
||||
for (int j = 0; j < k; ++j) {
|
||||
if (i & (1 << j)) ++num[idx];
|
||||
}
|
||||
idx++;
|
||||
}
|
||||
}
|
||||
cnt[k] = idx;
|
||||
}
|
||||
}
|
||||
inline bool place(int x, int y) {
|
||||
return (x & y) == x;
|
||||
}
|
||||
inline bool judge_1(int x, int y) {
|
||||
if ((x << 1) & y || (x >> 1) & y) return false;
|
||||
return true;
|
||||
}
|
||||
inline bool judge_2(int x, int y) {
|
||||
if (x & y) return false;
|
||||
return true;
|
||||
}
|
||||
int solve() {
|
||||
int ret = 0;
|
||||
memset(f, 0, sizeof (f));
|
||||
if (N == 1) {
|
||||
for (int i = 0; i < cnt[M]; ++i) {
|
||||
if (place(sta[i], mp[1])) {
|
||||
ret = max(ret, num[i]);
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
for (int i = 0; i < cnt[M]; ++i) {
|
||||
if (!place(sta[i], mp[2])) continue;
|
||||
for (int j = 0; j < cnt[M]; ++j) {
|
||||
if (!place(sta[j], mp[1])) continue;
|
||||
if (judge_1(sta[i], sta[j])) {
|
||||
f[2][i][j] = num[i] + num[j];
|
||||
}
|
||||
}
|
||||
}
|
||||
for (int i = 3; i <= N; ++i) {
|
||||
for (int j = 0; j < cnt[M]; ++j) {
|
||||
if (!place(sta[j], mp[i])) continue;
|
||||
for (int k = 0; k < cnt[M]; ++k) {
|
||||
if (!place(sta[k], mp[i-1]) || !judge_1(sta[j], sta[k])) continue;
|
||||
for (int h = 0; h < cnt[M]; ++h) {
|
||||
if (!place(sta[h], mp[i-2]) || !judge_1(sta[k], sta[h])) continue;
|
||||
if (judge_2(sta[j], sta[h])) {
|
||||
f[i][j][k] = max(f[i][j][k], f[i-1][k][h] + num[j]);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
for (int i = 0; i < cnt[M]; ++i) {
|
||||
for (int j = 0; j < cnt[M]; ++j) {
|
||||
ret = max(ret, f[N][i][j]);
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
int main() {
|
||||
init();
|
||||
int c;
|
||||
while (scanf("%d %d", &N, &M) != EOF) {
|
||||
memset(mp, 0, sizeof (mp));
|
||||
for (int i = 1; i <= N; ++i) {
|
||||
for (int j = 1; j <= M; ++j) {
|
||||
scanf("%d", &c);
|
||||
mp[i] <<= 1;
|
||||
mp[i] |= c;
|
||||
}
|
||||
}
|
||||
printf("%d\n", solve());
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,32 @@
|
|||
#include<iostream>
|
||||
const int inf=1<<30;
|
||||
using namespace std;
|
||||
int map[22][22];
|
||||
int dp[22][22];
|
||||
int n,m;
|
||||
int main(){
|
||||
while(~scanf("%d%d",&n,&m)){
|
||||
for(int i=1;i<=n;i++){
|
||||
for(int j=1;j<=m;j++){
|
||||
scanf("%d",&map[i][j]);
|
||||
dp[i][j]=inf;
|
||||
}
|
||||
}
|
||||
for(int i=1;i<=m;i++){
|
||||
dp[1][i]=0;
|
||||
}
|
||||
for(int i=2;i<=n;i++){
|
||||
for(int j=1;j<=m;j++){
|
||||
for(int k=1;k<=m;k++){
|
||||
dp[i][j]=min(dp[i][j],dp[i-1][k]+abs(map[i][j]-map[i-1][k]));
|
||||
}
|
||||
}
|
||||
}
|
||||
int ans=inf;
|
||||
for(int i=1;i<=m;i++){
|
||||
ans=min(ans,dp[n][i]);
|
||||
}
|
||||
printf("%d\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,73 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
#include <iostream>
|
||||
#include <queue>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
int s[20][100];
|
||||
void inite()
|
||||
{
|
||||
s[3][0]= 4; s[3][1] = 1, s[3][2] = 2, s[3][3] = 6, s[3][4] = 10;
|
||||
s[4][0] = 4;s[4][1] = 0, s[4][2] = 4, s[4][3] = 5, s[4][4] = 9;
|
||||
s[5][0] = 6; s[5][1] = 3, s[5][2] = 7, s[5][3] = 8, s[5][4] = 40;
|
||||
s[5][5] = 50, s[5][6] = 60;
|
||||
s[6][0] = 6, s[6][1] = 11, s[6][2] = 12, s[6][3] = 20, s[6][4] = 30;
|
||||
s[6][5] = 80, s[6][6] = 90;
|
||||
s[7][0] = 3, s[7][1] = 15, s[7][2] = 16, s[7][3] = 70;
|
||||
s[8][0] = 13, s[8][1] = 13, s[8][2] = 14, s[8][3] = 18, s[8][4] = 19;
|
||||
s[8][5] = 41, s[8][6] = 42, s[8][7] = 46, s[8][8] = 51, s[8][9] = 52;
|
||||
s[8][10] = 56,s[8][11] =61 ,s[8][12] = 62,s[8][13] = 66;
|
||||
s[9][0] = 22, s[9][1] = 17,s[9][2] = 21, s[9][3] = 22,s[9][4] = 26;
|
||||
s[9][5] = 31, s[9][6] = 32,s[9][7] = 36, s[9][8] = 44,s[9][9] = 45;
|
||||
s[9][10] = 49,s[9][11] = 54,s[9][12] = 55, s[9][13] = 59,s[9][14] = 64;
|
||||
s[9][15] = 65, s[9][16] = 69,s[9][17] = 81, s[9][18] = 82,s[9][19] = 86;
|
||||
s[9][20] = 91, s[9][21] = 92, s[9][22] = 96;
|
||||
s[10][0] = 25, s[10][1] = 24,s[10][2] = 25, s[10][3] = 29,s[10][4] = 34;
|
||||
s[10][5] = 35, s[10][6] = 39,s[10][7] = 43, s[10][8] = 47,s[10][9] = 48;
|
||||
s[10][10] = 53, s[10][11] = 57,s[10][12] = 58, s[10][13] = 63,s[10][14] = 67;
|
||||
s[10][15] = 68, s[10][16] = 71,s[10][17] = 72, s[10][18] = 76,s[10][19] = 84;
|
||||
s[10][20] = 85, s[10][21] = 89,s[10][22] = 94, s[10][23] = 95,s[10][24] = 99;
|
||||
s[10][25] = 100;
|
||||
s[11][0] = 15, s[11][1] = 23,s[11][2] = 27,s[11][3] = 28,s[11][4] = 33;
|
||||
s[11][5] = 37, s[11][6] = 38,s[11][7] = 74,s[11][8] = 75,s[11][9] = 79;
|
||||
s[11][10] = 83, s[11][11] = 87,s[11][12] = 88,s[11][13] = 93,s[11][14] = 97;
|
||||
s[11][15] = 98;
|
||||
s[12][0] = 3,s[12][1] = 73,s[12][2] = 77,s[12][3] = 78;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
inite();
|
||||
int T, cas = 0;
|
||||
for(scanf("%d", &T); T--; )
|
||||
{
|
||||
int a, b;
|
||||
scanf("%d%d", &a, &b);
|
||||
if((a < 3) || a > 12)
|
||||
printf("Case #%d: -1\n", ++cas);
|
||||
else
|
||||
{
|
||||
if(((s[a][0] < b) && (a != 9)) || ((a == 9) && (s[a][0] + 4< b)))
|
||||
printf("Case #%d: -1\n", ++cas);
|
||||
else
|
||||
{
|
||||
if(a == 9)
|
||||
{
|
||||
if(b <= 22)
|
||||
printf("Case #%d: %d\n", ++cas, s[a][b]);
|
||||
else if(b == 23)
|
||||
printf("Case #%d: 10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000\n", ++cas);
|
||||
else if(b == 24)
|
||||
printf("Case #%d: 20000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000\n", ++cas);
|
||||
else if(b == 25)
|
||||
printf("Case #%d: 60000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000\n", ++cas);
|
||||
else if(b == 26)
|
||||
printf("Case #%d: 100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000\n", ++cas);
|
||||
}
|
||||
else
|
||||
printf("Case #%d: %d\n", ++cas, s[a][b]);
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,112 @@
|
|||
#include <stdio.h>
|
||||
#include <iostream>
|
||||
#include <string.h>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
const int MAXN=100000;
|
||||
int prime[MAXN+1];
|
||||
void getPrime()
|
||||
{
|
||||
memset(prime,0,sizeof(prime));
|
||||
for(int i=2;i<=MAXN;i++)
|
||||
{
|
||||
if(!prime[i])prime[++prime[0]]=i;
|
||||
for(int j=1;j<=prime[0]&&prime[j]<=MAXN/i;j++)
|
||||
{
|
||||
prime[prime[j]*i]=1;
|
||||
if(i%prime[j]==0)break;
|
||||
}
|
||||
}
|
||||
}
|
||||
long long factor[100][2];
|
||||
int fatCnt;
|
||||
int getFactors(long long x)
|
||||
{
|
||||
fatCnt=0;
|
||||
long long tmp=x;
|
||||
for(int i=1;prime[i]<=tmp/prime[i];i++)
|
||||
{
|
||||
factor[fatCnt][1]=0;
|
||||
if(tmp%prime[i]==0)
|
||||
{
|
||||
factor[fatCnt][0]=prime[i];
|
||||
while(tmp%prime[i]==0)
|
||||
{
|
||||
factor[fatCnt][1]++;
|
||||
tmp/=prime[i];
|
||||
}
|
||||
fatCnt++;
|
||||
}
|
||||
}
|
||||
if(tmp!=1)
|
||||
{
|
||||
factor[fatCnt][0]=tmp;
|
||||
factor[fatCnt++][1]=1;
|
||||
}
|
||||
return fatCnt;
|
||||
}
|
||||
const long long INF=(1LL<<62)+1;
|
||||
int N;
|
||||
long long ans;
|
||||
long long a[47787];
|
||||
void dfs(int i,long long x,int n)
|
||||
{
|
||||
if(n>47777)return;
|
||||
if(x<INF && (a[n]==0||a[n]>x))a[n]=x;
|
||||
for(int j=1;j<=62;j++)
|
||||
{
|
||||
if(INF/prime[i]<x)break;
|
||||
x*=prime[i];
|
||||
if(x>=INF)break;
|
||||
dfs(i+1,x,n*(j+1));
|
||||
}
|
||||
}
|
||||
int get(int x)
|
||||
{
|
||||
getFactors(x);
|
||||
int ans=1;
|
||||
for(int i=0;i<fatCnt;i++)
|
||||
ans*=(factor[i][1]+1);
|
||||
return ans;
|
||||
}
|
||||
void solve2()
|
||||
{
|
||||
int x=2;
|
||||
while(x*x<=4*(N+x))
|
||||
{
|
||||
if(x==get(N+x))
|
||||
{
|
||||
printf("%d\n",N+x);
|
||||
return;
|
||||
}
|
||||
x++;
|
||||
}
|
||||
printf("Illegal\n");
|
||||
}
|
||||
void init()
|
||||
{
|
||||
memset(a,0,sizeof(a));
|
||||
dfs(1,1,1);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int T;
|
||||
getPrime();
|
||||
int iCase=0;
|
||||
scanf("%d",&T);
|
||||
int Type;
|
||||
init();
|
||||
while(T--)
|
||||
{
|
||||
iCase++;
|
||||
scanf("%d%d",&Type,&N);
|
||||
printf("Case %d: ",iCase);
|
||||
if(Type==0)
|
||||
{
|
||||
if(a[N]!=0)printf("%I64d\n",a[N]);
|
||||
else printf("INF\n");
|
||||
}
|
||||
else solve2();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,131 @@
|
|||
#include<cstdio>
|
||||
#include<cmath>
|
||||
#include<iostream>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
struct P{
|
||||
int x,y,dis;
|
||||
};
|
||||
int N,M,pnum;
|
||||
int map[80][80],a[80][80];
|
||||
P queue[100000];
|
||||
int front,rear;
|
||||
char s[200];
|
||||
P point[10000];
|
||||
void push(P p){
|
||||
queue[rear++] = p;
|
||||
}
|
||||
P pop(){
|
||||
++front;
|
||||
return queue[front - 1];
|
||||
}
|
||||
P D(P p,int dir){
|
||||
P p2 = p;
|
||||
if(dir == 0) --p2.x;
|
||||
else if(dir == 1) ++ p2.x;
|
||||
else if(dir == 2) -- p2.y;
|
||||
else ++p2.y;
|
||||
return p2;
|
||||
}
|
||||
bool check(P p){
|
||||
if(p.x >=0 && p.x < N && p.y >=0 && p.y < M && a[p.x][p.y] == 0)
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
void BFS()
|
||||
{
|
||||
rear = front = 0;
|
||||
for(int i=0; i<N; ++i)
|
||||
for(int j=0; j<M; ++j){
|
||||
if(a[i][j] == 1){
|
||||
P p;
|
||||
p.x = i;
|
||||
p.y = j;
|
||||
push(p);
|
||||
}
|
||||
}
|
||||
while(rear > front){
|
||||
P p = pop();
|
||||
for(int dir =0; dir < 4; dir ++){
|
||||
P p2;
|
||||
p2 = D(p,dir);
|
||||
if(check(p2)){
|
||||
a[p2.x][p2.y] = a[p.x][p.y] + 1;
|
||||
push(p2);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
bool cmp(P p1, P p2){
|
||||
return p1.dis < p2.dis;
|
||||
}
|
||||
int DIS(P p1,P p2){
|
||||
return abs(p1.x - p2.x) + abs(p1.y - p2.y);
|
||||
}
|
||||
int solve()
|
||||
{
|
||||
BFS();
|
||||
pnum = 0;
|
||||
for(int i=0; i<N; ++i){
|
||||
for(int j=0; j<M; ++j){
|
||||
if(a[i][j] > 1){
|
||||
P p;
|
||||
p.x = i;
|
||||
p.y = j;
|
||||
p.dis = a[i][j] - 1;
|
||||
point[pnum++] = p;
|
||||
}
|
||||
}
|
||||
}
|
||||
if(pnum == 0){
|
||||
if(N == 1) return (M-1) / 2;
|
||||
if(M == 1) return (N-1) / 2;
|
||||
return (2*N + 2*M - 4)/3;
|
||||
}
|
||||
sort(point,point+pnum,cmp);
|
||||
int q = 0,d = 1;
|
||||
while(q < pnum){
|
||||
bool flag = false;
|
||||
for(int i=q; i<pnum; ++i){
|
||||
for(int j=i+1;j<pnum; ++j){
|
||||
if(DIS(point[i],point[j]) < d) continue;
|
||||
for(int k=j+1; k<pnum; ++k){
|
||||
if(DIS(point[i],point[k]) >= d &&
|
||||
DIS(point[j],point[k]) >= d){
|
||||
flag = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if(flag) break;
|
||||
}
|
||||
if(flag) break;
|
||||
}
|
||||
if(flag == false) break;
|
||||
++d;
|
||||
while(q < pnum && point[q].dis < d){
|
||||
++q;
|
||||
}
|
||||
}
|
||||
return d-1;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int T,cas = 0;
|
||||
scanf("%d",&T);
|
||||
while(T--){
|
||||
++cas;
|
||||
int ans = 1;
|
||||
scanf("%d %d",&N,&M);
|
||||
gets(s);
|
||||
for(int i=0; i<N; ++i){
|
||||
gets(s);
|
||||
for(int j=0; j<M; ++j){
|
||||
map[i][j] = (s[j] == '.' ? 0 : 1);
|
||||
a[i][j] = map[i][j];
|
||||
}
|
||||
}
|
||||
ans = solve();
|
||||
printf("Case %d: %d\n",cas,ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,65 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
#include<stdlib.h>
|
||||
#include<algorithm>
|
||||
#include<iostream>
|
||||
#include<queue>
|
||||
#include<map>
|
||||
#include<vector>
|
||||
#include<math.h>
|
||||
using namespace std;
|
||||
typedef long long ll;
|
||||
typedef __int64 int64;
|
||||
const int maxn = 2000005;
|
||||
const int inf = 0x7fffffff;
|
||||
const double pi=acos(-1.0);
|
||||
const double eps = 1e-8;
|
||||
struct node{
|
||||
int pi,di;
|
||||
}a[ maxn ];
|
||||
int cmp( node a,node b ){
|
||||
if( a.di!=b.di ) return a.di>b.di;
|
||||
else return a.pi<b.pi;
|
||||
}
|
||||
int main(){
|
||||
int n,m;
|
||||
while( scanf("%d%d",&n,&m)==2 ){
|
||||
int cnt = 0;
|
||||
for( int i=0;i<n;i++ ){
|
||||
scanf("%d",&a[ i ].di);
|
||||
a[ i ].pi = -1;
|
||||
}
|
||||
cnt = n;
|
||||
for( int i=0;i<m;i++ ){
|
||||
scanf("%d",&a[ cnt ].di);
|
||||
cnt++;
|
||||
}
|
||||
cnt = n;
|
||||
for( int i=0;i<m;i++ ){
|
||||
scanf("%d",&a[ cnt ].pi);
|
||||
cnt++;
|
||||
}
|
||||
sort( a,a+cnt,cmp );
|
||||
__int64 ans = 0;
|
||||
bool flag = true;
|
||||
int kill = 0;
|
||||
priority_queue< int,vector<int>,greater<int> > q;
|
||||
for( int i=0;i<cnt&&kill<n;i++ ){
|
||||
if( a[ i ].pi<0 ){
|
||||
if( q.empty() ){
|
||||
flag = false;
|
||||
break;
|
||||
}
|
||||
ans += q.top();
|
||||
q.pop();
|
||||
kill++;
|
||||
}
|
||||
else{
|
||||
q.push( a[ i ].pi );
|
||||
}
|
||||
}
|
||||
if( flag == false ) printf("No\n");
|
||||
else printf("%I64d\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,65 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
#define N 1005
|
||||
int main()
|
||||
{
|
||||
char s1[N],s2[N];
|
||||
int mark[27][27];
|
||||
int i,j;
|
||||
int flag;
|
||||
int T;
|
||||
char x,y;
|
||||
scanf("%d",&T);
|
||||
int count=1;
|
||||
while(T--)
|
||||
{
|
||||
getchar();
|
||||
gets(s1);
|
||||
gets(s2);
|
||||
int n;
|
||||
scanf("%d",&n);
|
||||
memset(mark,0,sizeof(mark));
|
||||
while(n--)
|
||||
{
|
||||
getchar();
|
||||
scanf("%c %c",&x,&y);
|
||||
mark[x-'a'+1][y-'a'+1]=1;
|
||||
}
|
||||
int ln1,ln2;
|
||||
ln1=strlen(s1);
|
||||
ln2=strlen(s2);
|
||||
i=0;
|
||||
j=0;
|
||||
flag=0;
|
||||
for(i=0;i<ln1;i++)
|
||||
{
|
||||
if(j==ln2)
|
||||
break;
|
||||
if(s1[i]==s2[j])
|
||||
{
|
||||
j++;
|
||||
continue;
|
||||
}
|
||||
while(s2[j]!=s1[i])
|
||||
{
|
||||
if(j==ln2)
|
||||
{
|
||||
flag=1;
|
||||
break;
|
||||
}
|
||||
if(mark[s2[j]-'a'+1][s1[i]-'a'+1]==1)
|
||||
{
|
||||
j++;
|
||||
break;
|
||||
}
|
||||
else
|
||||
j++;
|
||||
}
|
||||
}
|
||||
if(!flag)
|
||||
printf("Case #%d: happy\n",count++);
|
||||
else
|
||||
printf("Case #%d: unhappy\n",count++);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,52 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
#include<stdlib.h>
|
||||
#include<algorithm>
|
||||
#include<queue>
|
||||
using namespace std;
|
||||
int n, m;
|
||||
const int maxn = 10011;
|
||||
struct Node
|
||||
{
|
||||
int sum;
|
||||
int nex;
|
||||
int ith;
|
||||
Node(){}
|
||||
Node(int sum_, int nex_, int ith_){sum = sum_, nex = nex_, ith = ith_;}
|
||||
bool operator<(const Node &b)const
|
||||
{return b.nex < nex;}
|
||||
};
|
||||
int a[maxn];
|
||||
int Cal(int m)
|
||||
{
|
||||
priority_queue<Node> q;
|
||||
Node lin;
|
||||
lin.sum = 0, lin.nex = a[0], lin.ith = 0;
|
||||
q.push(lin);
|
||||
int cnt = 0;
|
||||
a[n] = 0;
|
||||
while(cnt < m)
|
||||
{
|
||||
lin = q.top(); q.pop();
|
||||
if(lin.ith >= n) continue;
|
||||
q.push(Node(lin.sum, lin.sum + a[lin.ith + 1], lin.ith + 1));
|
||||
q.push(Node(lin.nex, lin.nex + a[lin.ith + 1], lin.ith + 1));
|
||||
cnt += 1;
|
||||
}
|
||||
for(m = 0; !q.empty(); m ++) a[m] = q.top().sum, q.pop();
|
||||
sort(a, a + m);
|
||||
return a[m - 1];
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int i, t, ca;
|
||||
for(scanf("%d", &t), ca = 1; ca <= t; ca ++)
|
||||
{
|
||||
scanf("%d%d", &n, &m);
|
||||
for(i = 0; i < n; i ++)
|
||||
scanf("%d", &a[i]);
|
||||
sort(a, a + n);
|
||||
printf("Case #%d: %d\n", ca, Cal(m));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,128 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <string>
|
||||
#include <map>
|
||||
#include <cstring>
|
||||
using namespace std;
|
||||
const int MAX_ = 400010;
|
||||
map<string,int>mp;
|
||||
struct point {
|
||||
int to,next, num;
|
||||
} edge[MAX_], qedge[MAX_];
|
||||
struct query {
|
||||
int u,v,lca;
|
||||
} q[MAX_];
|
||||
int V[MAX_], head[MAX_], d[MAX_], fa[MAX_], ind[MAX_];
|
||||
bool vis[MAX_];
|
||||
int M,L, T;
|
||||
int n, m;
|
||||
void adde(int from,int to,int c) {
|
||||
edge[M].to = to;
|
||||
edge[M].num = c;
|
||||
edge[M].next = V[from];
|
||||
V[from] = M++;
|
||||
}
|
||||
void addq(int from,int to,int c) {
|
||||
qedge[L].to = to;
|
||||
qedge[L].num = c;
|
||||
qedge[L].next = head[from];
|
||||
head[from] = L++;
|
||||
}
|
||||
int find(int x) {
|
||||
if(fa[x] == x)return fa[x];
|
||||
else return fa[x] = find(fa[x]);
|
||||
}
|
||||
void dfs(int k,int pri,int x) {
|
||||
d[x] = k;
|
||||
for(int i = V[x]; i != -1; i = edge[i].next) {
|
||||
if(edge[i].to != pri) {
|
||||
dfs(k+1,x,edge[i].to);
|
||||
}
|
||||
}
|
||||
}
|
||||
void tarjan(int x) {
|
||||
fa[x] = x;
|
||||
vis[x] = 1;
|
||||
for(int i = V[x]; i != -1; i = edge[i].next) {
|
||||
if(!vis[edge[i].to]) {
|
||||
tarjan(edge[i].to);
|
||||
fa[edge[i].to] = x;
|
||||
}
|
||||
}
|
||||
for(int i = head[x]; i != -1; i = qedge[i].next) {
|
||||
if(vis[qedge[i].to]) {
|
||||
q[qedge[i].num].lca = find(qedge[i].to);
|
||||
}
|
||||
}
|
||||
}
|
||||
void solve() {
|
||||
for(int i = 1; i <= n; i++) {
|
||||
if(ind[i] == 0) {
|
||||
dfs(0,-1,i);
|
||||
tarjan(i);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
int capture(char s[]) {
|
||||
if(mp.find(s) == mp.end()) {
|
||||
return mp[s] = ++T;
|
||||
} else return mp[s];
|
||||
}
|
||||
void init() {
|
||||
memset(V,-1,sizeof(V));
|
||||
memset(head,-1,sizeof(head));
|
||||
memset(ind,0,sizeof(ind));
|
||||
memset(vis,0,sizeof(vis));
|
||||
M = L = T = 0;
|
||||
mp.clear();
|
||||
for(int i = 0; i <= n; i++) {
|
||||
fa[i] = i;
|
||||
}
|
||||
}
|
||||
void read() {
|
||||
int s,t;
|
||||
char c1[50],c2[50];
|
||||
for(int i = 1; i < n; i++) {
|
||||
scanf("%s",c1);
|
||||
scanf("%s",c2);
|
||||
t = capture(c1);
|
||||
s = capture(c2);
|
||||
adde(s,t,1);
|
||||
adde(t,s,1);
|
||||
ind[t]++;
|
||||
}
|
||||
for(int i = 0; i < m; i++) {
|
||||
scanf("%s",c1);
|
||||
scanf("%s",c2);
|
||||
t = capture(c1);
|
||||
s = capture(c2);
|
||||
addq(s,t,i);
|
||||
addq(t,s,i);
|
||||
q[i].u = t;
|
||||
q[i].v = s;
|
||||
}
|
||||
}
|
||||
void print_ans() {
|
||||
for(int i = 0; i < m; i++) {
|
||||
int t;
|
||||
t = d[q[i].u] - d[q[i].lca];
|
||||
if(q[i].v != q[i].lca) {
|
||||
t++;
|
||||
}
|
||||
if(q[i].u == q[i].v) t = 0;
|
||||
printf("%d\n",t);
|
||||
}
|
||||
}
|
||||
int main() {
|
||||
int Case;
|
||||
scanf("%d",&Case);
|
||||
while(Case--) {
|
||||
scanf("%d%d",&n,&m);
|
||||
init();
|
||||
read();
|
||||
solve();
|
||||
print_ans();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,56 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cstring>
|
||||
using namespace std;
|
||||
bool mark[1000010];
|
||||
int num[1000010];
|
||||
int k;
|
||||
int Judge(int n){
|
||||
int ans=0;
|
||||
while(n){
|
||||
ans+=n%10;
|
||||
n/=10;
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
void IsPrime(){
|
||||
memset(mark,true,sizeof(mark));
|
||||
mark[0]=mark[1]=false;
|
||||
k=0;
|
||||
for(int i=2;i*i<1000000;i++){
|
||||
if(mark[i]){
|
||||
for(int j=i*i;j<1000000;j+=i)
|
||||
mark[j]=false;
|
||||
}
|
||||
}
|
||||
for(int i=2;i<=1000010;i++){
|
||||
if(mark[i]&&mark[Judge(i)]){
|
||||
num[++k]=i;
|
||||
}
|
||||
}
|
||||
}
|
||||
int Binary_Search(int l,int h,int number){
|
||||
while(l<=h){
|
||||
int mid=(l+h)/2;
|
||||
if(num[mid]==number)return mid;
|
||||
else if(num[mid]>number)h=mid-1;
|
||||
else l=mid+1;
|
||||
}
|
||||
return l;
|
||||
}
|
||||
int main(){
|
||||
IsPrime();
|
||||
int _case,n,m,t=1;
|
||||
scanf("%d",&_case);
|
||||
while(_case--){
|
||||
scanf("%d%d",&n,&m);
|
||||
int cnt=0;
|
||||
int pos1=Binary_Search(1,k,n);
|
||||
int pos2=Binary_Search(1,k,m);
|
||||
pos1--;
|
||||
if(num[pos2]==m)pos2++;
|
||||
cnt=pos2-pos1-1;
|
||||
printf("Case #%d: %d\n",t++,cnt);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,70 @@
|
|||
#include <stdio.h>
|
||||
#include <algorithm>
|
||||
#include <iostream>
|
||||
#include <string.h>
|
||||
using namespace std;
|
||||
const int MOD=1e9+7;
|
||||
struct Matrix
|
||||
{
|
||||
long long mat[2][2];
|
||||
};
|
||||
Matrix mul(Matrix a,Matrix b)
|
||||
{
|
||||
Matrix ret;
|
||||
for(int i=0;i<2;i++)
|
||||
for(int j=0;j<2;j++)
|
||||
{
|
||||
ret.mat[i][j]=0;
|
||||
for(int k=0;k<2;k++)
|
||||
{
|
||||
ret.mat[i][j]+=a.mat[i][k]*b.mat[k][j];
|
||||
ret.mat[i][j]%=(MOD-1);
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
Matrix pow_M(Matrix a,int n)
|
||||
{
|
||||
Matrix ret;
|
||||
memset(ret.mat,0,sizeof(ret.mat));
|
||||
ret.mat[0][0]=ret.mat[1][1]=1;
|
||||
Matrix temp=a;
|
||||
while(n)
|
||||
{
|
||||
if(n&1)ret=mul(ret,temp);
|
||||
temp=mul(temp,temp);
|
||||
n>>=1;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
long long pow_m(long long a,long long n)
|
||||
{
|
||||
long long ret=1;
|
||||
long long temp=a%MOD;
|
||||
while(n)
|
||||
{
|
||||
if(n&1)
|
||||
{
|
||||
ret*=temp;
|
||||
ret%=MOD;
|
||||
}
|
||||
temp*=temp;
|
||||
temp%=MOD;
|
||||
n>>=1;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int a,b,n;
|
||||
Matrix tmp;
|
||||
tmp.mat[0][0]=0;
|
||||
tmp.mat[0][1]=tmp.mat[1][0]=tmp.mat[1][1]=1;
|
||||
while(scanf("%d%d%d",&a,&b,&n)==3)
|
||||
{
|
||||
Matrix p=pow_M(tmp,n);
|
||||
int ans=(pow_m(a,p.mat[0][0])*pow_m(b,p.mat[1][0]))%MOD;
|
||||
printf("%d\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,39 @@
|
|||
#include <stdio.h>
|
||||
#include <algorithm>
|
||||
#include <string.h>
|
||||
#include <iostream>
|
||||
using namespace std;
|
||||
const int MAXN=110;
|
||||
char str[MAXN];
|
||||
char sta1[MAXN],sta2[MAXN];
|
||||
int main()
|
||||
{
|
||||
int T;
|
||||
scanf("%d",&T);
|
||||
while(T--)
|
||||
{
|
||||
scanf("%s",&str);
|
||||
int n=strlen(str);
|
||||
int t1=0,t2=0;
|
||||
int t=n-1;
|
||||
while(t>0 && str[t]=='0')t--;
|
||||
for(int i=t;i>=0;i--)
|
||||
if(str[i]!='0'&&str[i]<str[t])
|
||||
t=i;
|
||||
sta1[t1++]=str[t];
|
||||
for(int i=n-1;i>t;i--)sta2[t2++]=str[i];
|
||||
while(t1+t2<n && t>0)
|
||||
{
|
||||
int tmp=t-1;
|
||||
for(int j=tmp-1;j>=0;j--)
|
||||
if(str[j]<str[tmp])
|
||||
tmp=j;
|
||||
sta1[t1++]=str[tmp];
|
||||
for(int i=t-1;i>tmp;i--)sta2[t2++]=str[i];
|
||||
t=tmp;
|
||||
}
|
||||
for(int i=0;i<t1;i++)printf("%c",sta1[i]);
|
||||
for(int i=t2-1;i>=0;i--)printf("%c",sta2[i]);
|
||||
printf("\n");
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,48 @@
|
|||
#include <iostream>
|
||||
#include <stdio.h>
|
||||
using namespace std;
|
||||
int gcd(int a,int b)
|
||||
{
|
||||
if(b==0) return a;
|
||||
return gcd(b,a%b);
|
||||
}
|
||||
bool run_year(int z)
|
||||
{
|
||||
if((z%4==0&&z%100!=0)||(z%400==0))
|
||||
return true;
|
||||
else
|
||||
return false;
|
||||
}
|
||||
int month[]={0,31,29,31,30,31,30,31,31,30,31,30,31};
|
||||
int main()
|
||||
{
|
||||
int T,num=0;
|
||||
scanf("%d",&T);
|
||||
while(T--)
|
||||
{
|
||||
num++;
|
||||
int x,y,z;
|
||||
int fx,fy;
|
||||
int a,b;
|
||||
scanf("%d%d%d",&a,&b,&z);
|
||||
int ans=0;
|
||||
for(x=1;x<=12;x++)
|
||||
{
|
||||
for(y=1;y<=month[x];y++)
|
||||
{
|
||||
int g=gcd(x,y);
|
||||
if(a==g&&(b==(x*y)/g))
|
||||
{
|
||||
if(x==2&&y==29&&!run_year(z)) continue;
|
||||
ans++;
|
||||
fx=x;fy=y;
|
||||
}
|
||||
}
|
||||
}
|
||||
if(ans==0) printf("Case #%d: -1\n",num);
|
||||
else if(ans==1) printf("Case #%d: %04d/%02d/%02d\n",num,z,fx,fy);
|
||||
else
|
||||
printf("Case #%d: 1\n",num);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,196 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
const int L = 100000+10;
|
||||
struct node
|
||||
{
|
||||
int d,n,s;
|
||||
int ls,rs,ms;
|
||||
int nsl,nsr,nsm;
|
||||
} a[L<<2];
|
||||
void diaosi(int l,int r,int i)
|
||||
{
|
||||
a[i].d = 1;
|
||||
a[i].ls = a[i].rs = a[i].ms = 0;
|
||||
}
|
||||
void nvshen(int l,int r,int i)
|
||||
{
|
||||
a[i].n = 1;
|
||||
a[i].d = 0;
|
||||
a[i].ls = a[i].rs = a[i].ms = 0;
|
||||
a[i].nsl = a[i].nsr = a[i].nsm = 0;
|
||||
}
|
||||
void xuexi(int l,int r,int i)
|
||||
{
|
||||
a[i].s = 1;
|
||||
a[i].d = a[i].n = 0;
|
||||
a[i].ls = a[i].rs = a[i].ms = r-l+1;
|
||||
a[i].nsl = a[i].nsr = a[i].nsm = r-l+1;
|
||||
}
|
||||
void pushup(int l,int r,int i)
|
||||
{
|
||||
int mid = (l+r)>>1;
|
||||
a[i].ms = max(a[2*i].ms,a[2*i+1].ms);
|
||||
a[i].ms = max(a[i].ms,a[2*i].rs+a[2*i+1].ls);
|
||||
a[i].ls = a[2*i].ls;
|
||||
a[i].rs = a[2*i+1].rs;
|
||||
if(a[2*i].ls == mid-l+1)
|
||||
a[i].ls+=a[2*i+1].ls;
|
||||
if(a[2*i+1].rs == r-mid)
|
||||
a[i].rs+= a[2*i].rs;
|
||||
a[i].nsm = max(a[2*i].nsm,a[2*i+1].nsm);
|
||||
a[i].nsm = max(a[i].nsm,a[2*i].nsr+a[2*i+1].nsl);
|
||||
a[i].nsl = a[2*i].nsl;
|
||||
a[i].nsr = a[2*i+1].nsr;
|
||||
if(a[2*i].nsl == mid-l+1)
|
||||
a[i].nsl+=a[2*i+1].nsl;
|
||||
if(a[2*i+1].nsr == r-mid)
|
||||
a[i].nsr+= a[2*i].nsr;
|
||||
}
|
||||
void pushdown(int l,int r,int i)
|
||||
{
|
||||
int mid = (l+r)>>1;
|
||||
if(a[i].s)
|
||||
{
|
||||
xuexi(l,mid,2*i);
|
||||
xuexi(mid+1,r,2*i+1);
|
||||
a[i].s = 0;
|
||||
}
|
||||
if(a[i].d)
|
||||
{
|
||||
diaosi(l,mid,2*i);
|
||||
diaosi(mid+1,r,2*i+1);
|
||||
a[i].d = 0;
|
||||
}
|
||||
if(a[i].n)
|
||||
{
|
||||
nvshen(l,mid,2*i);
|
||||
nvshen(mid+1,r,2*i+1);
|
||||
a[i].n = 0;
|
||||
}
|
||||
}
|
||||
void study(int L,int R,int l,int r,int i)
|
||||
{
|
||||
if(L == l && R == r)
|
||||
{
|
||||
xuexi(l,r,i);
|
||||
return ;
|
||||
}
|
||||
int mid = (l+r)>>1;
|
||||
pushdown(l,r,i);
|
||||
if(R<=mid)
|
||||
study(L,R,l,mid,2*i);
|
||||
else if(L>mid)
|
||||
study(L,R,mid+1,r,2*i+1);
|
||||
else
|
||||
{
|
||||
study(L,mid,l,mid,2*i);
|
||||
study(mid+1,R,mid+1,r,2*i+1);
|
||||
}
|
||||
pushup(l,r,i);
|
||||
}
|
||||
void insert(int flag,int L,int R,int l,int r,int i)
|
||||
{
|
||||
if(l == L && r == R)
|
||||
{
|
||||
if(!flag)
|
||||
diaosi(l,r,i);
|
||||
else
|
||||
nvshen(l,r,i);
|
||||
return ;
|
||||
}
|
||||
int mid = (l+r)>>1;
|
||||
pushdown(l,r,i);
|
||||
if(R<=mid)
|
||||
insert(flag,L,R,l,mid,2*i);
|
||||
else if(L>mid)
|
||||
insert(flag,L,R,mid+1,r,2*i+1);
|
||||
else
|
||||
{
|
||||
insert(flag,L,mid,l,mid,2*i);
|
||||
insert(flag,mid+1,R,mid+1,r,2*i+1);
|
||||
}
|
||||
pushup(l,r,i);
|
||||
}
|
||||
int query(int flag,int t,int l,int r,int i)
|
||||
{
|
||||
if(l==r)
|
||||
return l;
|
||||
int mid = (l+r)>>1;
|
||||
pushdown(l,r,i);
|
||||
if(!flag)
|
||||
{
|
||||
if(a[2*i].ms>=t)
|
||||
return query(flag,t,l,mid,2*i);
|
||||
else if(a[2*i].rs+a[2*i+1].ls>=t)
|
||||
return mid-a[2*i].rs+1;
|
||||
else
|
||||
return query(flag,t,mid+1,r,2*i+1);
|
||||
}
|
||||
else
|
||||
{
|
||||
if(a[2*i].nsm>=t)
|
||||
return query(flag,t,l,mid,2*i);
|
||||
else if(a[2*i].nsr+a[2*i+1].nsl>=t)
|
||||
return mid-a[2*i].nsr+1;
|
||||
else
|
||||
return query(flag,t,mid+1,r,2*i+1);
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int t,i,x,y,ans,cas = 1,n,m;
|
||||
char str[20];
|
||||
scanf("%d",&t);
|
||||
while(t--)
|
||||
{
|
||||
scanf("%d%d",&n,&m);
|
||||
printf("Case %d:\n",cas++);
|
||||
study(1,n,1,n,1);
|
||||
while(m--)
|
||||
{
|
||||
scanf("%s",str);
|
||||
if(str[0] == 'D')
|
||||
{
|
||||
scanf("%d",&x);
|
||||
if(a[1].ms<x)
|
||||
printf("fly with yourself\n");
|
||||
else
|
||||
{
|
||||
ans = query(0,x,1,n,1);
|
||||
insert(0,ans,ans+x-1,1,n,1);
|
||||
printf("%d,let's fly\n",ans);
|
||||
}
|
||||
}
|
||||
else if(str[0] == 'N')
|
||||
{
|
||||
scanf("%d",&x);
|
||||
if(a[1].ms<x)
|
||||
{
|
||||
if(a[1].nsm<x)
|
||||
printf("wait for me\n");
|
||||
else
|
||||
{
|
||||
ans = query(1,x,1,n,1);
|
||||
insert(1,ans,ans+x-1,1,n,1);
|
||||
printf("%d,don't put my gezi\n",ans);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
ans = query(0,x,1,n,1);
|
||||
insert(1,ans,ans+x-1,1,n,1);
|
||||
printf("%d,don't put my gezi\n",ans);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
scanf("%d%d",&x,&y);
|
||||
study(x,y,1,n,1);
|
||||
printf("I am the hope of chinese chengxuyuan!!\n");
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,41 @@
|
|||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<iostream>
|
||||
#include<cstdlib>
|
||||
using namespace std;
|
||||
int numa[11],numb[11];
|
||||
int main()
|
||||
{
|
||||
int T,a,b;
|
||||
scanf("%d",&T);
|
||||
while(T--)
|
||||
{
|
||||
scanf("%d%d",&a,&b);
|
||||
int x=(a+b)/2;
|
||||
int y=a-x;
|
||||
int coua=0,coub=0;
|
||||
int ita=abs(x);
|
||||
int itb=abs(y);
|
||||
while(ita)
|
||||
{
|
||||
numa[coua++]=ita%10;
|
||||
ita/=10;
|
||||
}
|
||||
while(itb)
|
||||
{
|
||||
numb[coub++]=itb%10;
|
||||
itb/=10;
|
||||
}
|
||||
int xx=0,yy=0;
|
||||
for(int i=0;i<coua;i++)
|
||||
xx=xx*10+numa[i];
|
||||
for(int i=0;i<coub;i++)
|
||||
yy=yy*10+numb[i];
|
||||
if(x<0)
|
||||
xx=-xx;
|
||||
if(y<0)
|
||||
yy=-yy;
|
||||
printf("%d %d\n",xx+yy,xx-yy);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,33 @@
|
|||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<iostream>
|
||||
using namespace std;
|
||||
const int maxn=1000011;
|
||||
int n;
|
||||
long long ans[maxn],phi[maxn];
|
||||
void Phi(int n)
|
||||
{
|
||||
phi[1]=1;
|
||||
for(int i=2;i<=n;i++)
|
||||
if(!phi[i])
|
||||
for(int j=i;j<=n;j+=i)
|
||||
{
|
||||
if(!phi[j])
|
||||
phi[j]=j;
|
||||
phi[j]=phi[j]/i*(i-1);
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
Phi(maxn-1);
|
||||
ans[1]=2;
|
||||
ans[2]=3;
|
||||
for(int i=3;i<maxn;i++)
|
||||
ans[i]=ans[i-1]+phi[i];
|
||||
while(scanf("%d",&n)!=EOF)
|
||||
{
|
||||
long long s=(ans[n]-2)*2+3;
|
||||
printf("%I64d\n",s);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,60 @@
|
|||
#include<iostream>
|
||||
#include<list>
|
||||
#include<cstdio>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
struct node
|
||||
{
|
||||
string name;
|
||||
int grade;
|
||||
int time;
|
||||
node(string s,int a,int b):name(s),grade(a),time(b){}
|
||||
friend bool operator<(const node& a,const node& b)
|
||||
{
|
||||
if(a.grade!=b.grade)
|
||||
return a.grade<b.grade;
|
||||
else return a.time<b.time;
|
||||
}
|
||||
friend bool operator==(const node& a,const node& b)
|
||||
{
|
||||
return a.grade>=b.grade;
|
||||
}
|
||||
};
|
||||
int main()
|
||||
{
|
||||
int cas,n,num;
|
||||
cin>>cas;
|
||||
string op,name;
|
||||
int time;
|
||||
for(int c=1;c<=cas;c++)
|
||||
{
|
||||
cin>>n;printf("Case #%d:\n",c);
|
||||
list<node>li;
|
||||
time=1;
|
||||
for(int i=0;i<n;i++)
|
||||
{
|
||||
cin>>op;
|
||||
if(op[0]=='A')
|
||||
{
|
||||
cin>>name>>num;
|
||||
li.push_back(node(name,num,i));
|
||||
li.sort();
|
||||
cout<<li.size()<<endl;
|
||||
}
|
||||
else
|
||||
{
|
||||
cin>>num;
|
||||
list<node>::iterator iter=find(li.begin(),li.end(),node("",num,0));
|
||||
if(iter!=li.end())
|
||||
{
|
||||
cout<<iter->name<<endl;
|
||||
li.erase(iter);
|
||||
}
|
||||
else
|
||||
{
|
||||
cout<<"WAIT..."<<endl;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,50 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<math.h>
|
||||
#include<cstring>
|
||||
#define MP make_pair
|
||||
#define SQ(x) ((x)*(x))
|
||||
typedef long long int64;
|
||||
const double PI = acos(-1.0);
|
||||
const int MAXN = 110;
|
||||
const int INF = 0x3f3f3f3f;
|
||||
using namespace std;
|
||||
const int MOD = 1000000007;
|
||||
int n, m;
|
||||
int f[2][480][22][2];
|
||||
int mat[480][480];
|
||||
char str[1000];
|
||||
int main(){
|
||||
int nCase, cas=1;
|
||||
scanf("%d", &nCase);
|
||||
while(nCase--){
|
||||
scanf("%d%d%*c", &n, &m);
|
||||
for(int i=1; i<=n; ++i){
|
||||
gets(str);
|
||||
for(int j=1; j<=m; ++j)
|
||||
mat[i][j] = str[j-1]-'0';
|
||||
}
|
||||
memset(f, 0, sizeof(f));
|
||||
int ans = 0;
|
||||
bool p = 0;
|
||||
for(int i=1; i<=n; ++i){
|
||||
p = !p;
|
||||
memset(f[p], 0, sizeof(f[p]));
|
||||
for(int j=1; j<=m; ++j){
|
||||
for(int k=0; k<=10; ++k){
|
||||
int x1 = (k+mat[i][j])%11;
|
||||
int x2 = (k-mat[i][j]+11)%11;
|
||||
f[p][j][k][0] += ((f[!p][j][x1][1]+f[p][j-1][x1][1])%MOD)%MOD;
|
||||
f[p][j][k][1] += ((f[!p][j][x2][0]+f[p][j-1][x2][0])%MOD)%MOD;
|
||||
}
|
||||
++f[p][j][11-mat[i][j]][0];
|
||||
}
|
||||
for(int j=1; j<=m; ++j){
|
||||
ans += (f[p][j][0][0] + f[p][j][0][1])%MOD;
|
||||
ans %= MOD;
|
||||
}
|
||||
}
|
||||
printf("Case %d: %d\n",cas++, ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,54 @@
|
|||
#include<iostream>
|
||||
#include<stdio.h>
|
||||
#include<algorithm>
|
||||
#include<iomanip>
|
||||
#include<cmath>
|
||||
#include<cstring>
|
||||
#include<vector>
|
||||
#define ll __int64
|
||||
#define pi acos(-1.0)
|
||||
#define MAX 5000
|
||||
using namespace std;
|
||||
int an[2][MAX],sg[MAX];
|
||||
bool vis[MAX];
|
||||
int getsg(int x)
|
||||
{
|
||||
int i;
|
||||
if(sg[x]>=0) return sg[x];
|
||||
memset(vis,0,sizeof(vis));
|
||||
for(i=0;i<=x-i-1;i++)
|
||||
vis[getsg(i)^getsg(x-i-1)^1]=1;
|
||||
for(i=0;i<=x-i-2;i++)
|
||||
vis[getsg(i)^getsg(x-i-2)]=1;
|
||||
i=0;
|
||||
while(vis[i]) i++;
|
||||
return sg[x]=i;
|
||||
}
|
||||
int main(){
|
||||
int t,m,n,s,c,ans,i,k=0,len;
|
||||
memset(sg,-1,sizeof(sg));
|
||||
sg[0]=0;
|
||||
for(i=1;i<=4747;i++) sg[i]=getsg(i);
|
||||
scanf("%d",&t);
|
||||
while(t--){
|
||||
scanf("%d %d",&n,&m);
|
||||
memset(an,0,sizeof(an));
|
||||
for(i=0;i<m;i++){
|
||||
scanf("%d %d",&s,&c);
|
||||
an[s-1][c-1]=1;
|
||||
}
|
||||
ans=0;len=0;
|
||||
for(i=0;i<n;i++){
|
||||
if(an[0][i]||an[1][i]){
|
||||
ans^=sg[len];
|
||||
ans^=an[0][i];
|
||||
ans^=an[1][i];
|
||||
len=0;
|
||||
}
|
||||
else len++;
|
||||
}
|
||||
ans^=sg[len];
|
||||
printf("Case %d: %s\n",++k,ans?"Alice":"Bob");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,104 @@
|
|||
#include <iostream>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <algorithm>
|
||||
#include <queue>
|
||||
#include <vector>
|
||||
#include <map>
|
||||
#include <set>
|
||||
#include <string>
|
||||
#include <math.h>
|
||||
using namespace std;
|
||||
const int MAXN=1100;
|
||||
int maze[MAXN][MAXN];
|
||||
int gap[MAXN],dis[MAXN],pre[MAXN],cur[MAXN];
|
||||
int flow[MAXN][MAXN];
|
||||
int sap(int start,int end,int nodenum)
|
||||
{
|
||||
memset(cur,0,sizeof(cur));
|
||||
memset(dis,0,sizeof(dis));
|
||||
memset(gap,0,sizeof(gap));
|
||||
memset(flow,0,sizeof(flow));
|
||||
int u=pre[start]=start,maxflow=0,aug=-1;
|
||||
gap[0]=nodenum;
|
||||
while(dis[start]<nodenum)
|
||||
{
|
||||
loop:
|
||||
for(int v=cur[u];v<nodenum;v++)
|
||||
if(maze[u][v]-flow[u][v] && dis[u]==dis[v]+1)
|
||||
{
|
||||
if(aug==-1 || aug>maze[u][v]-flow[u][v])aug=maze[u][v]-flow[u][v];
|
||||
pre[v]=u;
|
||||
u=cur[u]=v;
|
||||
if(v==end)
|
||||
{
|
||||
maxflow+=aug;
|
||||
for(u=pre[u];v!=start;v=u,u=pre[u])
|
||||
{
|
||||
flow[u][v]+=aug;
|
||||
flow[v][u]-=aug;
|
||||
}
|
||||
aug=-1;
|
||||
}
|
||||
goto loop;
|
||||
}
|
||||
int mindis=nodenum-1;
|
||||
for(int v=0;v<nodenum;v++)
|
||||
if(maze[u][v]-flow[u][v]&&mindis>dis[v])
|
||||
{
|
||||
cur[u]=v;
|
||||
mindis=dis[v];
|
||||
}
|
||||
if((--gap[dis[u]])==0)break;
|
||||
gap[dis[u]=mindis+1]++;
|
||||
u=pre[u];
|
||||
}
|
||||
return maxflow;
|
||||
}
|
||||
bool used[MAXN][MAXN];
|
||||
int main()
|
||||
{
|
||||
int T;
|
||||
int N,M,L,K;
|
||||
scanf("%d",&T);
|
||||
int iCase=0;
|
||||
while(T--)
|
||||
{
|
||||
iCase++;
|
||||
scanf("%d%d%d%d",&N,&M,&L,&K);
|
||||
memset(maze,0,sizeof(maze));
|
||||
int u,v;
|
||||
memset(used,false,sizeof(used));
|
||||
while(L--)
|
||||
{
|
||||
scanf("%d%d",&u,&v);
|
||||
used[u][v]=true;
|
||||
}
|
||||
for(int i=N+1;i<=N+M;i++)maze[i][i+M]=K;
|
||||
for(int i=1;i<=N;i++)
|
||||
for(int j=1;j<=M;j++)
|
||||
{
|
||||
if(used[i][j])
|
||||
{
|
||||
maze[i][j+N+M]=1;
|
||||
}
|
||||
else maze[i][j+N]=1;
|
||||
}
|
||||
int ans=0;
|
||||
int l=0,r=M;
|
||||
while(l<=r)
|
||||
{
|
||||
int mid=(l+r)/2;
|
||||
for(int i=1;i<=N;i++)maze[0][i]=mid;
|
||||
for(int i=N+M+1;i<=N+2*M;i++)maze[i][N+2*M+1]=mid;
|
||||
if(sap(0,N+2*M+1,N+2*M+2)==mid*N)
|
||||
{
|
||||
ans=mid;
|
||||
l=mid+1;
|
||||
}
|
||||
else r=mid-1;
|
||||
}
|
||||
printf("Case %d: %d\n",iCase,ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,72 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
int tCase,n,a[10000+1];
|
||||
int num[10000+1];
|
||||
int z,f,o;
|
||||
int solve(int s,int t)
|
||||
{
|
||||
f=0;
|
||||
for(int i=s;i<t;i++)
|
||||
{
|
||||
if(a[i]<0) f++;
|
||||
}
|
||||
if(f%2==0)
|
||||
{
|
||||
return t-s;
|
||||
}
|
||||
else
|
||||
{
|
||||
int ans=0,tag1=s-1,tag2=t,a1,a2,a3,a4,m=t-s;
|
||||
for(int i=s;i<t;i++)
|
||||
{
|
||||
if(a[i]<0)
|
||||
{
|
||||
tag1=i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
a1=m-(tag1-s+1);
|
||||
a3=tag1-s;
|
||||
if(a1<a3) a1=a3;
|
||||
for(int i=t-1;i>=s;i--)
|
||||
{
|
||||
if(a[i]<0)
|
||||
{
|
||||
tag2=i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
a2=tag2-s;
|
||||
a4=t-1-tag2;
|
||||
if(a2<a4) a2=a4;
|
||||
ans=max(ans,max(a1,a2));
|
||||
return ans;
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
scanf("%d",&tCase);
|
||||
for(int i=1;i<=tCase;i++)
|
||||
{
|
||||
scanf("%d",&n);
|
||||
o=0;
|
||||
for(int j=1;j<=n;j++)
|
||||
{
|
||||
scanf("%d",&a[j]);
|
||||
if(a[j]==0)
|
||||
num[o++]=j;
|
||||
}
|
||||
num[o++]=n+1;
|
||||
int t=1;
|
||||
int ans=0;
|
||||
for(int j=0;j<o;j++)
|
||||
{
|
||||
ans=max(ans,solve(t,num[j]));
|
||||
t=num[j]+1;
|
||||
}
|
||||
printf("Case #%d: %d\n",i,ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,99 @@
|
|||
#include <iostream>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <algorithm>
|
||||
#include <map>
|
||||
#include <vector>
|
||||
#include <set>
|
||||
#include <queue>
|
||||
#include <string>
|
||||
#include <math.h>
|
||||
using namespace std;
|
||||
const int MAXN=1010;
|
||||
struct Node
|
||||
{
|
||||
int x,y;
|
||||
int r;
|
||||
};
|
||||
bool cmp(Node a,Node b)
|
||||
{
|
||||
return a.r<b.r;
|
||||
}
|
||||
int dis2(Node a,Node b)
|
||||
{
|
||||
return ((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));
|
||||
}
|
||||
Node node[MAXN];
|
||||
Node node1[MAXN];
|
||||
Node node2[MAXN];
|
||||
int dp1[MAXN];
|
||||
int dp2[MAXN];
|
||||
int main()
|
||||
{
|
||||
int T;
|
||||
int n;
|
||||
int iCase=0;
|
||||
Node st;
|
||||
st.x=0;st.y=0;
|
||||
Node ed;
|
||||
scanf("%d",&T);
|
||||
while(T--)
|
||||
{
|
||||
iCase++;
|
||||
printf("Case %d: ",iCase);
|
||||
scanf("%d",&n);
|
||||
scanf("%d%d",&ed.x,&ed.y);
|
||||
int t1=0;
|
||||
int t2=0;
|
||||
for(int i=0;i<n;i++)
|
||||
{
|
||||
scanf("%d%d%d",&node[i].x,&node[i].y,&node[i].r);
|
||||
int d1=dis2(st,node[i]);
|
||||
int d2=dis2(ed,node[i]);
|
||||
if(d1==node[i].r*node[i].r||d2==node[i].r*node[i].r)
|
||||
continue;
|
||||
if(d1<node[i].r*node[i].r&&d2<node[i].r*node[i].r)continue;
|
||||
if(d1>node[i].r*node[i].r&&d2>node[i].r*node[i].r)continue;
|
||||
if(d1<node[i].r*node[i].r)
|
||||
{
|
||||
node1[t1++]=node[i];
|
||||
}
|
||||
else node2[t2++]=node[i];
|
||||
}
|
||||
sort(node1,node1+t1,cmp);
|
||||
sort(node2,node2+t2,cmp);
|
||||
int ans1=0,ans2=0;
|
||||
for(int i=0;i<t1;i++)
|
||||
{
|
||||
dp1[i]=1;
|
||||
for(int j=0;j<i;j++)
|
||||
{
|
||||
int d=dis2(node1[i],node1[j]);
|
||||
if(node1[i].r>node1[j].r && d<(node1[i].r-node1[j].r)*(node1[i].r-node1[j].r))
|
||||
dp1[i]=max(dp1[i],dp1[j]+1);
|
||||
}
|
||||
ans1=max(ans1,dp1[i]);
|
||||
}
|
||||
for(int i=0;i<t2;i++)
|
||||
{
|
||||
dp2[i]=1;
|
||||
for(int j=0;j<i;j++)
|
||||
{
|
||||
int d=dis2(node2[i],node2[j]);
|
||||
if( node2[i].r>node2[j].r && d<(node2[i].r-node2[j].r)*(node2[i].r-node2[j].r))
|
||||
dp2[i]=max(dp2[i],dp2[j]+1);
|
||||
}
|
||||
ans2=max(ans2,dp2[i]);
|
||||
}
|
||||
int ans=max(ans1,ans2);
|
||||
for(int i=0;i<t1;i++)
|
||||
for(int j=0;j<t2;j++)
|
||||
{
|
||||
int d1=dis2(node1[i],node2[j]);
|
||||
if(d1>(node1[i].r+node2[j].r)*(node1[i].r+node2[j].r))
|
||||
ans=max(ans,dp1[i]+dp2[j]);
|
||||
}
|
||||
printf("%d\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,72 @@
|
|||
#include <algorithm>
|
||||
#include <iostream>
|
||||
#include <string>
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
#include <math.h>
|
||||
#include <stdlib.h>
|
||||
#include <vector>
|
||||
#include <queue>
|
||||
#include <stack>
|
||||
#include <cmath>
|
||||
#include <list>
|
||||
#include <set>
|
||||
#include <map>
|
||||
using namespace std;
|
||||
#define N 100010
|
||||
#define E 100010
|
||||
#define ll long long
|
||||
const int INF =0x3fffffff;
|
||||
const int PRIME =999983;
|
||||
const int MOD =1000000007;
|
||||
const int MULTI =1000000007;
|
||||
const double EPS=1e-8;
|
||||
#define CUBE(x) ((x)*(x)*(x))
|
||||
#define SQ(x) ((x)*(x))
|
||||
#define ALL(x) x.begin(),x.end()
|
||||
#define CLR(x,a) memset(x,a,sizeof(x))
|
||||
#define maxAry(a,n) max_element(a,a+(n))
|
||||
#define minAry(a,n) min_element(a,a+(n))
|
||||
inline bool isodd(int x){return x&1;}
|
||||
inline bool isodd(ll x) {return x&1;}
|
||||
double dp[110];
|
||||
int vx[110],vy[110];
|
||||
int n,L;
|
||||
double gao(int x)
|
||||
{
|
||||
fill(dp,dp+L+1,-1);
|
||||
dp[0]=0;
|
||||
for(int i=0;i<n;i++){
|
||||
if(i==x) continue;
|
||||
for(int j=L;j>=0;j--){
|
||||
for(int k=0;k<=100;k++){
|
||||
if(j-vx[i]*k<0 || dp[j-vx[i]*k]==-1) continue;
|
||||
if(dp[j]==-1) dp[j]=dp[j-vx[i]*k]+vy[i]*k-0.5*9.8*SQ(k);
|
||||
else dp[j]=max(dp[j],dp[j-vx[i]*k]+vy[i]*k-0.5*9.8*SQ(k));
|
||||
}
|
||||
}
|
||||
}
|
||||
double ans=-INF;
|
||||
for(int i=0;i<=L;i++){
|
||||
if(dp[i]==-1) continue;
|
||||
double t=1.0*(L-i)/vx[x];
|
||||
ans=max(ans,dp[i]+vy[x]*t-0.5*9.8*SQ(t));
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int re,Case=1;
|
||||
double ans;
|
||||
scanf("%d",&re);
|
||||
while(re--){
|
||||
scanf("%d%d",&n,&L);
|
||||
for(int i=0;i<n;i++)
|
||||
scanf("%d%d",&vx[i],&vy[i]);
|
||||
ans=-INF;
|
||||
for(int i=0;i<n;i++)
|
||||
ans=max(ans,gao(i));
|
||||
printf("Case %d: %.3lf\n",Case++,ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,24 @@
|
|||
#include <cstdio>
|
||||
typedef long long llg;
|
||||
llg a,b,n,m;
|
||||
void solve(){
|
||||
llg ans1(1),ans2(0),t1(a),t2(1);
|
||||
llg tmp;
|
||||
while(n){
|
||||
if(n&1){
|
||||
tmp = ans1;
|
||||
ans1 = (ans1*t1+ans2*t2*b)%m;
|
||||
ans2 = (tmp*t2+ans2*t1)%m;
|
||||
}
|
||||
tmp = t1;
|
||||
t1 = (t1*t1+t2*t2*b)%m;
|
||||
t2 = 2*tmp*t2%m;
|
||||
n >>= 1;
|
||||
}
|
||||
printf("%lld\n",ans1*2%m);
|
||||
}
|
||||
int main(){
|
||||
while(~scanf("%lld%lld%lld%lld",&a,&b,&n,&m))
|
||||
solve();
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,106 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <algorithm>
|
||||
#include <bitset>
|
||||
#include <vector>
|
||||
#include <ctime>
|
||||
using namespace std;
|
||||
typedef long long LL;
|
||||
const int N = 100000;
|
||||
const int M = 50;
|
||||
const LL MAXS = 1LL<<50;
|
||||
const LL MAXT = (LL)1e16;
|
||||
inline LL two( int x ) { return 1LL<<x; }
|
||||
LL f[M+1][N+5], g[M+1][N+5], a[N+5];
|
||||
int ran[2][2][N+5];
|
||||
int n , m;
|
||||
LL s;
|
||||
void solve( LL t , LL &ans1, LL &ans2) {
|
||||
fill( f[0], f[0]+n+1, 0 );
|
||||
fill( g[0], g[0]+n+1, 0 );
|
||||
f[0][0] = 1;
|
||||
int bits[55], bitt[55];
|
||||
for( int i = 0 ; i < m; ++i ) {
|
||||
bits[i] = (s&two(i))>0;
|
||||
bitt[i] = (t&two(i))>0;
|
||||
}
|
||||
ran[0][0][0] = n;
|
||||
ran[0][1][0] = 0;
|
||||
for( int i = 1; i <= n; ++i ) {
|
||||
ran[0][0][i] = i-1;
|
||||
}
|
||||
for( int i = 1; i <= m; ++i ) {
|
||||
int cur = i&1, pre = cur^1 ;
|
||||
fill( f[i], f[i]+n+1, 0 );
|
||||
fill( g[i], g[i]+n+1, 0 );
|
||||
for( int j = 0 ; j < 2; ++j ) ran[cur][j][0] = 0;
|
||||
for( int j = 1 ; j >= 0; --j ) {
|
||||
for( int k = 1 ; k <= ran[pre][j][0]; ++k ) {
|
||||
int idx = ran[pre][j][k];
|
||||
if( a[idx] & two(i-1) ) ran[cur][1][ ++ran[cur][1][0] ] = idx ;
|
||||
else ran[cur][0][ ++ran[cur][0][0] ] = idx ;
|
||||
}
|
||||
}
|
||||
int oneCnt = 0, curOnes = ran[cur][1][0], curZeros = ran[cur][0][0];
|
||||
for( int j = 0; j <= n; ++j ) {
|
||||
int idx = -1, presize1 = ran[pre][1][0];
|
||||
if( j > presize1 ) {
|
||||
idx = ran[pre][0][j-presize1];
|
||||
} else {
|
||||
if( j > 0 ) idx = ran[pre][1][j];
|
||||
}
|
||||
if( idx != -1 && (a[idx]&two(i-1)) != 0 ) {
|
||||
++oneCnt;
|
||||
}
|
||||
int tBit = bitt[i-1];
|
||||
int curOne = curOnes + j - 2*oneCnt;
|
||||
if( (curOne&1) == bits[i-1] ) {
|
||||
if( tBit == 0 ) {
|
||||
f[i][ oneCnt ] += f[i-1][j];
|
||||
g[i][ oneCnt ] += g[i-1][j];
|
||||
} else {
|
||||
f[i][ oneCnt ] += f[i-1][j]+g[i-1][j];
|
||||
}
|
||||
}
|
||||
curOne = curZeros - j + 2*oneCnt;
|
||||
int nextOne = j + curOnes - oneCnt;
|
||||
if( (curOne&1) == bits[i-1] ) {
|
||||
if( tBit == 0 ) {
|
||||
g[i][ nextOne ] += g[i-1][j] + f[i-1][j];
|
||||
} else {
|
||||
f[i][ nextOne] += f[i-1][j];
|
||||
g[i][ nextOne] += g[i-1][j];
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
ans1 = ans2 = 0;
|
||||
for( int i = 0 ; i <= n; ++i ) {
|
||||
ans1 += f[m][i];
|
||||
ans2 += g[m][i];
|
||||
}
|
||||
ans2 += ans1;
|
||||
return ;
|
||||
}
|
||||
int main() {
|
||||
LL t;
|
||||
int start = clock();
|
||||
while( scanf("%d%d%lld%lld",&n,&m,&s,&t) != EOF ) {
|
||||
if( t > MAXT ) {
|
||||
cerr<<t<<" "<<MAXT<<endl;
|
||||
}
|
||||
LL x = 0;
|
||||
for( int i = 0 ; i < n; ++i ) {
|
||||
scanf("%lld",&a[i]);
|
||||
x ^= a[i];
|
||||
}
|
||||
LL M = 1LL << m, loops = t/M;
|
||||
LL ans1, ans2;
|
||||
solve( t%M ,ans1, ans2);
|
||||
loops *= ans2;
|
||||
loops += ans1;
|
||||
if( x == s ) loops--;
|
||||
printf("%lld\n", loops);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,34 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cmath>
|
||||
#include<cstring>
|
||||
#include<algorithm>
|
||||
#include<string>
|
||||
using namespace std;
|
||||
__int64 l[1000005],v[1000005],r;
|
||||
int main()
|
||||
{
|
||||
__int64 n,i,j,k,b;
|
||||
int t=0;
|
||||
while(~scanf("%I64d",&n))
|
||||
{
|
||||
t++;
|
||||
if(t>=40) continue;
|
||||
memset(l,0,sizeof l);
|
||||
for(i=1;i<=n;i++)
|
||||
{
|
||||
scanf("%I64d",&v[i]);
|
||||
l[i]=l[i-1]+v[i]+1;
|
||||
if(l[i-1]<=v[i]) k=i;
|
||||
}
|
||||
for(i=k+1,r=0,b=0;i<=n;i++)
|
||||
{
|
||||
b+=(v[i]<=b);
|
||||
r+=max(0ll,v[i]-b);
|
||||
}
|
||||
if((r+l[k-1])==v[k]) printf("%I64d\n",k);
|
||||
else if((r+l[k-1])>v[k]) printf("Unknown\n");
|
||||
else printf("Bad Rescue\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,92 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<algorithm>
|
||||
#include<queue>
|
||||
using namespace std;
|
||||
#define MAXN 222
|
||||
#define inf 1<<30
|
||||
struct Point{
|
||||
int x,y;
|
||||
}point[MAXN];
|
||||
int value[MAXN][MAXN];
|
||||
int map[MAXN][MAXN];
|
||||
int dist[MAXN][MAXN];
|
||||
int dd[MAXN];
|
||||
bool mark[MAXN][MAXN];
|
||||
int dp[1<<14][14];
|
||||
int n,m,k;
|
||||
int dir[4][2]={{-1,0},{1,0},{0,-1},{0,1}};
|
||||
void spfa(int num)
|
||||
{
|
||||
memset(mark,false,sizeof(mark));
|
||||
for(int i=0;i<n;i++)
|
||||
for(int j=0;j<m;j++)dist[i][j]=inf;
|
||||
queue<pair<int,int> >que;
|
||||
que.push(make_pair(point[num].x,point[num].y));
|
||||
if(dist[point[num].x][point[num].y]==-1)return;
|
||||
dist[point[num].x][point[num].y]=0;
|
||||
while(!que.empty()){
|
||||
int x=que.front().first,y=que.front().second;
|
||||
que.pop();
|
||||
mark[x][y]=false;
|
||||
if(x==0||x==(n-1)||y==0||y==(m-1)){
|
||||
dd[num]=min(dd[num],dist[x][y]);
|
||||
}
|
||||
for(int i=0;i<4;i++){
|
||||
int xx=x+dir[i][0],yy=y+dir[i][1];
|
||||
if(xx>=0&&xx<n&&yy>=0&&yy<m&&value[xx][yy]!=-1){
|
||||
if(dist[x][y]+value[xx][yy]<dist[xx][yy]){
|
||||
dist[xx][yy]=dist[x][y]+value[xx][yy];
|
||||
if(!mark[xx][yy]){
|
||||
mark[xx][yy]=true;
|
||||
que.push(make_pair(xx,yy));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int _case;
|
||||
scanf("%d",&_case);
|
||||
while(_case--){
|
||||
scanf("%d%d",&n,&m);
|
||||
for(int i=0;i<n;i++)
|
||||
for(int j=0;j<m;j++)
|
||||
scanf("%d",&value[i][j]);
|
||||
scanf("%d",&k);
|
||||
for(int i=0;i<k;i++)scanf("%d%d",&point[i].x,&point[i].y);
|
||||
for(int i=0;i<k;i++)
|
||||
for(int j=0;j<k;j++)
|
||||
map[i][j]=(i==j)?0:inf;
|
||||
for(int i=0;i<(1<<k);i++)
|
||||
for(int j=0;j<k;j++)dp[i][j]=inf;
|
||||
fill(dd,dd+MAXN,inf);
|
||||
for(int i=0;i<k;i++){
|
||||
spfa(i);
|
||||
for(int j=0;j<k;j++){
|
||||
if(i==j)continue;
|
||||
map[i][j]=min(map[i][j],dist[point[j].x][point[j].y]);
|
||||
}
|
||||
dp[1<<i][i]=dd[i]+value[point[i].x][point[i].y];
|
||||
}
|
||||
for(int s=0;s<(1<<k);s++){
|
||||
for(int i=0;i<k;i++){
|
||||
if(s&(1<<i)==0)continue;
|
||||
if(dp[s][i]==inf)continue;
|
||||
for(int j=0;j<k;j++){
|
||||
if(s&(1<<j)==1)continue;
|
||||
dp[s|(1<<j)][j]=min(dp[s|(1<<j)][j],dp[s][i]+map[i][j]);
|
||||
}
|
||||
}
|
||||
}
|
||||
int ans=inf;
|
||||
for(int i=0;i<k;i++){
|
||||
ans=min(ans,dp[(1<<k)-1][i]+dd[i]);
|
||||
}
|
||||
printf("%d\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,51 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
#include <math.h>
|
||||
#include <stack>
|
||||
#include <queue>
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
int a[5], pri, n;
|
||||
__int64 f(int x,int i)
|
||||
{
|
||||
int j;
|
||||
__int64 sum=0;
|
||||
for(j=0;j<i;j++){
|
||||
sum = (sum+a[j])*x;
|
||||
}
|
||||
return sum+a[j];
|
||||
}
|
||||
void solve()
|
||||
{
|
||||
int i, j, k;
|
||||
int pri2 = pri*pri;
|
||||
for(i=0;i<pri;i++)
|
||||
{
|
||||
if( (f(i,n))%pri==0 ){
|
||||
for(j=i;j<pri2;j+=pri)
|
||||
{
|
||||
if( f(j,n)%pri2==0 ){
|
||||
printf("%d\n",j);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
printf("No solution!\n");
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int cse;
|
||||
cin>>cse;
|
||||
for(int t=1;t<=cse;t++)
|
||||
{
|
||||
scanf("%d",&n);
|
||||
for(int i=0;i<=n;i++) scanf("%d",&a[i]);
|
||||
scanf("%d",&pri);
|
||||
printf("Case #%d: ",t);
|
||||
solve();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,45 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
int n;
|
||||
__int64 dp[70][70],a[70],sum[70];
|
||||
__int64 pow(__int64 n)
|
||||
{
|
||||
__int64 ans= 1;
|
||||
int i;
|
||||
for(i = 1; i<=n; i++)
|
||||
ans*=2;
|
||||
return ans;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int t,i,j,k,s;
|
||||
scanf("%d",&t);
|
||||
while(t--)
|
||||
{
|
||||
scanf("%d",&n);
|
||||
memset(sum,0,sizeof(sum));
|
||||
for(i = 1; i<=n; i++)
|
||||
{
|
||||
scanf("%I64d",&a[i]);
|
||||
sum[i] = sum[i-1]+a[i];
|
||||
}
|
||||
memset(dp,0,sizeof(dp));
|
||||
for(s = 0; s<=n; s++)
|
||||
{
|
||||
for(i = 1; i<=n && i+s<=n; i++)
|
||||
{
|
||||
j = i+s;
|
||||
if(s<=19)
|
||||
dp[i][j] =a[i]*pow(j-i)*2;
|
||||
else
|
||||
dp[i][j] = (sum[j]-sum[i-1])*2;
|
||||
for(k = i; k<=j; k++)
|
||||
dp[i][j] = min(dp[i][j],dp[i][k]+dp[k+1][j]);
|
||||
}
|
||||
}
|
||||
printf("%I64d\n",dp[1][n]);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,102 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <algorithm>
|
||||
#include <queue>
|
||||
#include <cstring>
|
||||
using namespace std;
|
||||
const int maxn=110;
|
||||
const int oo=0x3fffffff;
|
||||
int S[maxn], C[maxn];
|
||||
int mp[maxn], visit[maxn][3*maxn];
|
||||
int map[maxn][maxn], cap[maxn][maxn], dis[maxn][3*maxn];
|
||||
int n, m, V, T, st, sd, ss, dd;
|
||||
struct node
|
||||
{
|
||||
int u, t;
|
||||
};
|
||||
void floyd()
|
||||
{
|
||||
ss=n, dd=n+1, S[dd]=0;
|
||||
for(int k=0; k<n; k++)
|
||||
for(int i=0; i<n; i++)
|
||||
for(int j=0; j<n; j++)
|
||||
if(map[i][j]>map[i][k]+map[k][j]) map[i][j]=map[i][k]+map[k][j];
|
||||
for(int i=0; i<n; i++)
|
||||
for(int j=i+1; j<n; j++)
|
||||
{
|
||||
if(map[i][j]!=oo)
|
||||
{
|
||||
if(S[i]<S[j]) cap[i][j]=map[i][j]+C[j];
|
||||
if(S[j]<S[i]) cap[j][i]=map[i][j]+C[i];
|
||||
}
|
||||
}
|
||||
cap[ss][st]=C[st];
|
||||
for(int i=0; i<n; i++)
|
||||
if(i!=st&&map[st][i]!=oo) cap[ss][i]=map[st][i]+C[i];
|
||||
for(int i=0; i<n; i++)
|
||||
if(i!=sd&&map[i][sd]!=oo) cap[i][dd]=map[i][sd];
|
||||
}
|
||||
int spfa()
|
||||
{
|
||||
queue<node>q;
|
||||
for(int i=0; i<=n+1; i++)
|
||||
for(int j=0; j<=V; j++) dis[i][j]=-oo, visit[i][j]=0;
|
||||
node s, p;
|
||||
s.u=ss, s.t=0;
|
||||
q.push(s);
|
||||
dis[ss][0]=0;
|
||||
visit[ss][0]=1;
|
||||
while(!q.empty())
|
||||
{
|
||||
p=q.front();
|
||||
q.pop();
|
||||
visit[p.u][p.t]=0;
|
||||
for(int i=0; i<=n+1; i++)
|
||||
{
|
||||
if(p.u!=i&&cap[p.u][i]!=oo)
|
||||
{
|
||||
int tp=p.t+cap[p.u][i];
|
||||
if(tp<=V&&dis[i][tp]<dis[p.u][p.t]+S[i])
|
||||
{
|
||||
dis[i][tp]=dis[p.u][p.t]+S[i];
|
||||
s.u=i, s.t=tp;
|
||||
if(!visit[s.u][s.t]) visit[s.u][s.t]=1,q.push(s);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
int maxx=0;
|
||||
for(int i=0; i<=V; i++)
|
||||
{
|
||||
maxx=max(maxx,dis[sd][i]);
|
||||
maxx=max(maxx,dis[dd][i]);
|
||||
}
|
||||
return maxx;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
cin >> T;
|
||||
for(int tcase=1; tcase<=T; tcase++)
|
||||
{
|
||||
scanf("%d%d%d%d%d",&n,&m,&V,&st,&sd);
|
||||
for(int i=0; i<=n+1; i++)
|
||||
for(int j=0; j<=n+1; j++)
|
||||
{
|
||||
map[i][j]=oo, cap[i][j]=oo;
|
||||
if(i==j) map[i][j]=cap[i][j]=0;
|
||||
}
|
||||
for(int i=0; i<n; i++) scanf("%d",C+i);
|
||||
for(int i=0; i<n; i++) scanf("%d",S+i);
|
||||
while(m--)
|
||||
{
|
||||
int u, v, val;
|
||||
scanf("%d%d%d",&u,&v,&val);
|
||||
map[u][v]=min(map[u][v],val);
|
||||
map[v][u]=min(map[v][u],val);
|
||||
}
|
||||
floyd();
|
||||
int ans=spfa();
|
||||
printf("Case #%d:\n%d\n",tcase,ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,14 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <queue>
|
||||
using namespace std;
|
||||
int main()
|
||||
{
|
||||
int N,M;
|
||||
while(scanf("%d%d",&M,&N)!=EOF)
|
||||
{
|
||||
printf("%d\n",(M+(M-(N-1)/2)+1)*(N-1)/4+(M+(M-(N+1)/2)+1)*(N+1)/4);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,121 @@
|
|||
#include <cstdio>
|
||||
#include <cmath>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
#define db double
|
||||
#define rt return
|
||||
#define cs const
|
||||
#define cp const P&
|
||||
#define op operator
|
||||
cs db eps = 1e-9;
|
||||
inline int sig(db x){rt (x>eps)-(x<-eps);}
|
||||
cs int N = 10001;
|
||||
struct P {
|
||||
db x, y, z;
|
||||
P(db a = 0, db b = 0, db c = 0):x(a),y(b),z(c){}
|
||||
void in(){scanf("%lf%lf%lf", &x, &y, &z);}
|
||||
P op+(cp a)cs{rt P(x+a.x, y+a.y, z+a.z);}
|
||||
P op-(cp a)cs{rt P(x-a.x, y-a.y, z-a.z);}
|
||||
P op*(cs db&k)cs{rt P(x*k, y*k, z*k);}
|
||||
P op^(cp a)cs{rt P(y*a.z-a.y*z, z*a.x-a.z*x, x*a.y-a.x*y);}
|
||||
db op*(cp a)cs{rt x*a.x + y*a.y + z*a.z;}
|
||||
P cross(P a, P b){rt a-*this ^ b-*this;}
|
||||
db dot(P a, P b){rt (a-*this) * (b-*this);}
|
||||
db L(){rt sqrt(x*x + y*y + z*z);}
|
||||
db V6(P b, P c){rt (b ^ c) * (*this);}
|
||||
}p[N];
|
||||
int n;
|
||||
db diff_vol, max_diff;
|
||||
struct convex {
|
||||
int cnt, blg[N][N];
|
||||
struct face {
|
||||
int a, b, c, is;
|
||||
face(int x=0,int y=0,int z=0,int w=0):a(x),b(y),c(z),is(w){}
|
||||
int visible(P me) {
|
||||
rt sig(p[a].cross(p[b],p[c]) * (me-p[a])) > 0;
|
||||
}
|
||||
}fac[N*10];
|
||||
int col(int a, int b, int c){rt p[a].cross(p[b],p[c]).L() < eps;}
|
||||
int cop(int a, int b, int c, int d){rt !sig(p[a].cross(p[b],p[c])*(p[d]-p[a]));}
|
||||
void deal(int k, int a, int b) {
|
||||
int f = blg[a][b];
|
||||
if(fac[f].is) {
|
||||
if(fac[f].visible(p[k])) dfs(k, f);
|
||||
else {
|
||||
diff_vol += p[b].V6(p[a], p[k]);
|
||||
face add = face(b, a, k, 1);
|
||||
blg[b][a] = blg[a][k] = blg[k][b] = cnt;
|
||||
fac[cnt++] = add;
|
||||
}
|
||||
}
|
||||
}
|
||||
void dfs(int k, int cur) {
|
||||
diff_vol -= p[fac[cur].a].V6(p[fac[cur].b], p[fac[cur].c]);
|
||||
fac[cur].is = 0;
|
||||
deal(k, fac[cur].b, fac[cur].a);
|
||||
deal(k, fac[cur].c, fac[cur].b);
|
||||
deal(k, fac[cur].a, fac[cur].c);
|
||||
}
|
||||
void init() {
|
||||
cnt = 0;
|
||||
for(int i = 0; i < 4; i++) {
|
||||
face add = face((i+1)%4, (i+2)%4, (i+3)%4, 1);
|
||||
if(add.visible(p[i])) swap(add.b, add.c);
|
||||
blg[add.a][add.b] = blg[add.b][add.c] = blg[add.c][add.a] = cnt;
|
||||
fac[cnt++] = add;
|
||||
}
|
||||
}
|
||||
void update(int k) {
|
||||
for(int i = 0; i < cnt; i++)
|
||||
if(fac[i].is && fac[i].visible(p[k])) {
|
||||
dfs(k, i); break;
|
||||
}
|
||||
}
|
||||
db volume() {
|
||||
db v = 0.;
|
||||
for(int i = 0; i < cnt; i++)
|
||||
v += fac[i].is * p[fac[i].a].V6(p[fac[i].b], p[fac[i].c]);
|
||||
rt v / 6.;
|
||||
}
|
||||
}hull;
|
||||
void solve(int number, int cas) {
|
||||
max_diff = 0.;
|
||||
int king = 1, tag = 1;
|
||||
p[0].in();
|
||||
for(int i = 1; i < number; i++) {
|
||||
p[i].in();
|
||||
if(tag == 1) {
|
||||
tag += sig((p[0]-p[i]).L());
|
||||
if(tag > 1) swap(p[1], p[i]);
|
||||
continue;
|
||||
}
|
||||
if(tag == 2) {
|
||||
tag += sig((p[0].cross(p[1], p[i])).L());
|
||||
if(tag > 2) swap(p[2], p[i]);
|
||||
continue;
|
||||
}
|
||||
if(tag == 3) {
|
||||
tag += sig(p[0].cross(p[1], p[2]) * (p[i]-p[0])) != 0;
|
||||
if(tag > 3) {
|
||||
swap(p[3], p[i]);
|
||||
hull.init();
|
||||
for(int j = 4; j <= i; j++) hull.update(j);
|
||||
king = i + 1, max_diff = hull.volume();
|
||||
}
|
||||
continue;
|
||||
}
|
||||
diff_vol = 0.;
|
||||
hull.update(i);
|
||||
diff_vol /= 6.;
|
||||
if(sig(diff_vol - max_diff) > 0) {
|
||||
max_diff = diff_vol;
|
||||
king = i + 1;
|
||||
}
|
||||
}
|
||||
printf("Case #%d:\n%d %.2lf\n", cas, king, max_diff);
|
||||
}
|
||||
int main() {
|
||||
int number, cas = 1;
|
||||
while(scanf("%d", &number) != -1) solve(number, cas++);
|
||||
rt 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,84 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cmath>
|
||||
#include <cstring>
|
||||
#include <queue>
|
||||
#include <vector>
|
||||
#define mp(a , b) make_pair(a , b)
|
||||
using namespace std;
|
||||
typedef long long LL;
|
||||
const LL inf = 1000000000LL;
|
||||
int a , b , l , r , k;
|
||||
int pow (int a , int b) {
|
||||
int ret = 1;
|
||||
for (int i = 0 ; i < b ; i ++) {
|
||||
ret = ret * a;
|
||||
if (ret > inf || ret <= 0)
|
||||
return inf + 1;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
int gao (int c , int a , int b , int l , int r , int k) {
|
||||
if (c == 0) return l <= r;
|
||||
if (c == 1) {
|
||||
if (l > r) return 0;
|
||||
return max (0 , min(r , b) - max (l , a) + 1);
|
||||
}
|
||||
int down = max(a , l / pow(b , c - 1));
|
||||
int up = min (b , r / pow(a , c - 1));
|
||||
int ret = 0;
|
||||
for (int i = down ; i <= up ; i ++) {
|
||||
ret += gao (c - 1 , i , b , (l + i - 1) / i , r / i , k - ret);
|
||||
if (ret > k) return ret;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
int ret , ans[50];
|
||||
void fuck (int c , int a , int b , int l , int r , int k) {
|
||||
if (c == 0) return;
|
||||
if (c == 1) {
|
||||
int num = k + max(l , a) - 1;
|
||||
ret = ret * num;
|
||||
ans[c] = num;
|
||||
return ;
|
||||
}
|
||||
int down = max(a , l / pow(b , c - 1));
|
||||
int up = min (b , r / pow(a , c - 1));
|
||||
for (int i = down ; i <= up ; i ++) {
|
||||
int cnt = gao (c - 1 , i , b , (l + i - 1) / i , r / i , k);
|
||||
if (k > cnt) {
|
||||
k -= cnt;
|
||||
continue;
|
||||
}
|
||||
ret = ret * i;
|
||||
ans[c] = i;
|
||||
fuck (c - 1 , i , b , (l + i - 1) / i , r / i , k);
|
||||
return ;
|
||||
}
|
||||
}
|
||||
int main () {
|
||||
int t , cas = 0;
|
||||
scanf ("%d" , &t);
|
||||
while (t --) {
|
||||
bool ok = false;
|
||||
scanf ("%d %d %d %d %d" , &a , &b , &l , &r , &k);
|
||||
printf ("Case #%d: " , ++ cas);
|
||||
for (int i = 1 ; i <= 30 ; i ++) {
|
||||
int cnt = gao (i , a , b , l , r , k);
|
||||
if (k > cnt) {
|
||||
k -= cnt;
|
||||
continue;
|
||||
}
|
||||
ret = 1;
|
||||
fuck (i , a , b , l , r , k);
|
||||
printf ("%d\n" , ret);
|
||||
for (int j = i ; j >= 1 ; j --) {
|
||||
printf ("%d%c" , ans[j] , j == 1 ? '\n' : ' ');
|
||||
}
|
||||
ok = true;
|
||||
break;
|
||||
}
|
||||
if (!ok) puts("-1");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,196 @@
|
|||
#include <iostream>
|
||||
#include <cassert>
|
||||
#include <cmath>
|
||||
#include <cstdio>
|
||||
#include <cstdlib>
|
||||
#include <vector>
|
||||
#include <map>
|
||||
using namespace std;
|
||||
#define inf 9e99
|
||||
#define eps 1e-9
|
||||
#define x first
|
||||
#define y second
|
||||
#define pb push_back
|
||||
#define sz(a) int(a.size())
|
||||
#define rep(i,a,b) for(int i=a;i<=b;i++)
|
||||
template<class T> inline void gmin(T&a,T b) {if(a>b)a=b;}
|
||||
template<class T> inline T sqr(T a) {return a*a;}
|
||||
#define N 20020
|
||||
vector<int> to[N],len[N];
|
||||
int col[N],n;
|
||||
double sum[N],L;
|
||||
#define is_leaf(x) sz(to[x])==1 && sum[to[x][0]]<sum[x]
|
||||
void pre_dfs(int x) {
|
||||
rep(i,0,sz(to[x])-1) {
|
||||
int y=to[x][i];
|
||||
if (sum[y]<0) {
|
||||
col[y]=x==1?y:col[x];
|
||||
sum[y]=sum[x]+len[x][i];
|
||||
pre_dfs(y);
|
||||
}
|
||||
}
|
||||
}
|
||||
vector<int> path,tmp[N];
|
||||
double dp1[N],ans1[N];
|
||||
double dp2[N],ans2[N];
|
||||
double Y1(int j) {return dp1[j]+sqrt(dp1[j])+sqr(sum[j])+2.0*sum[j]*L;}
|
||||
double Y2(int j) {return dp2[j]+sqrt(dp2[j])+sqr(sum[j])-2.0*sum[j]*L;}
|
||||
double slope1(int j,int k) {return (Y1(j)-Y1(k))/(sum[j]-sum[k]);}
|
||||
double slope2(int j,int k) {return (Y2(j)-Y2(k))/(sum[j]-sum[k]);}
|
||||
double calc(double Ej,double sum) {return Ej+sqrt(Ej)+sum*sum;}
|
||||
struct Queue {
|
||||
map<double,int> q;
|
||||
void clear() {q.clear();}
|
||||
int size() {return q.size();}
|
||||
int front() {return sz(q)?q.begin()->y:0;}
|
||||
int front2() {return sz(q)?(++q.begin())->y:0;}
|
||||
int back() {return sz(q)?q.rbegin()->y:0;}
|
||||
int back2() {return sz(q)?(++q.rbegin())->y:0;}
|
||||
void pop_front() {q.erase(q.begin());}
|
||||
void pop_back() {q.erase(--q.end());}
|
||||
void insert(int x,int y) {q[x]=y;}
|
||||
void merge(Queue *b) {
|
||||
while (b->size()) {
|
||||
int cur=b->front();
|
||||
b->pop_front();
|
||||
if (q.find(sum[cur])!=q.end()) {
|
||||
int j=cur,k=q[sum[cur]];
|
||||
if (Y2(j)>=Y2(k)) continue;
|
||||
}
|
||||
q[sum[cur]]=cur;
|
||||
if (sz(q)<=2) continue;
|
||||
map<double,int>::iterator i=q.find(sum[cur]),l1,l2,r1,r2;
|
||||
if (i!=q.begin() && i!=(--q.end())) {
|
||||
l1=i, l1--;
|
||||
r1=i, r1++;
|
||||
if (slope2(l1->y,i->y)>=slope2(i->y,r1->y)) {
|
||||
q.erase(i);
|
||||
continue;
|
||||
}
|
||||
}
|
||||
while (i!=q.begin() && i!=(++q.begin())) {
|
||||
l1=i, l1--;
|
||||
l2=l1, l2--;
|
||||
if (slope2(l2->y,l1->y)<=slope2(l1->y,i->y)) break;
|
||||
q.erase(l1);
|
||||
}
|
||||
while (i!=(--q.end()) && i!=(--(--q.end()))) {
|
||||
r1=i, r1++;
|
||||
r2=r1, r2++;
|
||||
if (slope2(i->y,r1->y)<=slope2(r1->y,r2->y)) break;
|
||||
q.erase(r1);
|
||||
}
|
||||
}
|
||||
}
|
||||
} q1,*q2[N];
|
||||
void first_run(int x) {
|
||||
rep(i,0,sz(to[x])-1) {
|
||||
int y=to[x][i];
|
||||
if (sum[y]<=sum[x]) continue;
|
||||
path.pb(y);
|
||||
tmp[x].clear();
|
||||
while (sz(q1)>=2 && slope1(q1.front(),q1.front2())<=2.0*sum[y] ) {
|
||||
tmp[x].pb(q1.front());
|
||||
q1.pop_front();
|
||||
}
|
||||
dp1[y]=calc(dp1[q1.front()],sum[y]-sum[q1.front()]-L);
|
||||
while (sz(q1)>=2 && slope1(q1.back2(),q1.back())>=slope1(q1.back(),y) ) {
|
||||
tmp[x].pb(q1.back());
|
||||
q1.pop_back();
|
||||
}
|
||||
q1.insert(sum[y],y);
|
||||
first_run(y);
|
||||
q1.pop_back();
|
||||
rep(i,0,sz(tmp[x])-1)
|
||||
q1.insert(sum[tmp[x][i]],tmp[x][i]);
|
||||
path.pop_back();
|
||||
}
|
||||
if (is_leaf(x)) {
|
||||
gmin(ans1[col[x]],dp1[x]);
|
||||
}
|
||||
}
|
||||
void merge(Queue *&a,Queue *&b) {
|
||||
if (b->size() < a->size()) {
|
||||
a->merge(b);
|
||||
} else {
|
||||
b->merge(a);
|
||||
a=b;
|
||||
}
|
||||
}
|
||||
double get_val(Queue *q,int x) {
|
||||
while (q->size()>=2 && slope2(q->back(),q->back2())>=2.0*sum[x]) q->pop_back();
|
||||
dp2[x]=calc(dp2[q->back()],sum[q->back()]-sum[x]-L);
|
||||
while (q->size()>=2 && slope2(q->front2(),q->front())<=slope2(q->front(),x) ) q->pop_front();
|
||||
return dp2[x];
|
||||
}
|
||||
void second_run(int x) {
|
||||
q2[x]=new Queue;
|
||||
rep(i,0,sz(to[x])-1){
|
||||
int y=to[x][i];
|
||||
if (sum[y]<=sum[x]) continue;
|
||||
second_run(y);
|
||||
if (x==1) {
|
||||
gmin(ans2[y],get_val(q2[y],x));
|
||||
} else {
|
||||
merge(q2[x],q2[y]);
|
||||
}
|
||||
}
|
||||
if (x!=1) {
|
||||
dp2[x]=is_leaf(x)?0:get_val(q2[x],x);
|
||||
q2[x]->insert(sum[x],x);
|
||||
}
|
||||
}
|
||||
double get_answer() {
|
||||
vector<int> part;
|
||||
rep(i,2,n) if (col[i]==i) part.pb(i);
|
||||
double min1=inf,min2=inf;
|
||||
int pos1;
|
||||
rep(i,0,sz(part)-1) {
|
||||
if (min1>ans2[part[i]]) {
|
||||
min2=min1;
|
||||
min1=ans2[part[i]];
|
||||
pos1=i;
|
||||
} else
|
||||
if (min2>ans2[part[i]]) {
|
||||
min2=ans2[part[i]];
|
||||
}
|
||||
}
|
||||
double res=inf;
|
||||
rep(i,0,sz(part)-1)
|
||||
gmin(res,ans1[part[i]]+(pos1==i?min2:min1));
|
||||
return res;
|
||||
}
|
||||
int main() {
|
||||
while (~scanf("%d%lf",&n,&L)) {
|
||||
rep(i,1,n) {
|
||||
to[i].clear();
|
||||
len[i].clear();
|
||||
}
|
||||
rep(i,1,n-1) {
|
||||
int u,v,w;
|
||||
scanf("%d%d%d",&u,&v,&w);
|
||||
to[u].pb(v);
|
||||
to[v].pb(u);
|
||||
len[u].pb(w);
|
||||
len[v].pb(w);
|
||||
}
|
||||
if (sz(to[1])<2) {
|
||||
puts("-1");
|
||||
continue;
|
||||
}
|
||||
fill(sum+2,sum+n+1,-1);
|
||||
pre_dfs(1);
|
||||
fill(dp1+2,dp1+n+1,inf);
|
||||
fill(dp2+1,dp2+n+1,inf);
|
||||
fill(ans1,ans1+n+1,inf);
|
||||
fill(ans2,ans2+n+1,inf);
|
||||
path.clear();
|
||||
path.pb(1);
|
||||
q1.clear();
|
||||
q1.insert(0,1);
|
||||
first_run(1);
|
||||
second_run(1);
|
||||
printf("%.2lf\n",get_answer());
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,34 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cstring>
|
||||
using namespace std;
|
||||
const int N=220;
|
||||
int n,m,l,r;
|
||||
double dp[2][N];
|
||||
int main(){
|
||||
while(~scanf("%d%d%d%d",&n,&m,&l,&r)){
|
||||
if(n==0 && m==0 && l==0 && r==0)
|
||||
break;
|
||||
for(int i=0;i<=n;i++)
|
||||
dp[0][i]=0;
|
||||
dp[0][0]=1;
|
||||
int x,cur=0;
|
||||
while(m--){
|
||||
scanf("%d",&x);
|
||||
for(int i=0;i<n;i++)
|
||||
dp[cur^1][i]=0;
|
||||
for(int i=0;i<n;i++){
|
||||
if(dp[cur][i]==0)
|
||||
continue;
|
||||
dp[cur^1][((i-x)%n+n)%n]+=0.5*dp[cur][i];
|
||||
dp[cur^1][(i+x)%n]+=0.5*dp[cur][i];
|
||||
}
|
||||
cur^=1;
|
||||
}
|
||||
double ans=0;
|
||||
for(int i=l-1;i<r;i++)
|
||||
ans+=dp[cur][i];
|
||||
printf("%.4lf\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,147 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<algorithm>
|
||||
#include<cstring>
|
||||
using namespace std;
|
||||
#define lz 2*u,l,mid
|
||||
#define rz 2*u+1,mid+1,r
|
||||
typedef long long lld;
|
||||
const int maxn=100005;
|
||||
const int mod=10007;
|
||||
lld add[4*maxn], mul[4*maxn], ch[4*maxn], sum[4*maxn];
|
||||
void build(int u, int l, int r)
|
||||
{
|
||||
mul[u]=1;
|
||||
add[u]=sum[u]=0;
|
||||
ch[u]=0;
|
||||
if(l==r)
|
||||
{
|
||||
ch[u]=1;
|
||||
return ;
|
||||
}
|
||||
int mid=(l+r)>>1;
|
||||
build(lz);
|
||||
build(rz);
|
||||
}
|
||||
void push_down(int u, int l, int r)
|
||||
{
|
||||
if(l==r) return ;
|
||||
int mid=(l+r)>>1;
|
||||
if(ch[u])
|
||||
{
|
||||
add[2*u]=0, mul[2*u]=1;
|
||||
add[2*u+1]=0, mul[2*u+1]=1;
|
||||
ch[2*u]=ch[2*u+1]=1;
|
||||
sum[2*u]=sum[2*u+1]=sum[u];
|
||||
ch[u]=0;
|
||||
}
|
||||
else
|
||||
{
|
||||
if(add[u])
|
||||
{
|
||||
if(ch[2*u]) sum[2*u]=(sum[2*u]+add[u])%mod;
|
||||
else
|
||||
{
|
||||
push_down(lz);
|
||||
add[2*u]=(add[2*u]+add[u])%mod;
|
||||
}
|
||||
if(ch[2*u+1]) sum[2*u+1]=(sum[2*u+1]+add[u])%mod;
|
||||
else
|
||||
{
|
||||
push_down(rz);
|
||||
add[2*u+1]=(add[2*u+1]+add[u])%mod;
|
||||
}
|
||||
add[u]=0;
|
||||
}
|
||||
if(mul[u]>1)
|
||||
{
|
||||
if(ch[2*u]) sum[2*u]=(sum[2*u]*mul[u])%mod;
|
||||
else
|
||||
{
|
||||
push_down(lz);
|
||||
mul[2*u]=(mul[2*u]*mul[u])%mod;
|
||||
}
|
||||
if(ch[2*u+1]) sum[2*u+1]=(sum[2*u+1]*mul[u])%mod;
|
||||
else
|
||||
{
|
||||
push_down(rz);
|
||||
mul[2*u+1]=(mul[2*u+1]*mul[u])%mod;
|
||||
}
|
||||
mul[u]=1;
|
||||
}
|
||||
}
|
||||
}
|
||||
void Update(int u, int l, int r, int tl, int tr, int c, int op)
|
||||
{
|
||||
if(tl<=l&&r<=tr)
|
||||
{
|
||||
if(op==3)
|
||||
{
|
||||
ch[u]=1;
|
||||
mul[u]=1, add[u]=0;
|
||||
sum[u]=c;
|
||||
}
|
||||
else
|
||||
{
|
||||
if(ch[u])
|
||||
{
|
||||
if(op==1) sum[u]=(sum[u]+c)%mod;
|
||||
else sum[u]=sum[u]*c%mod;
|
||||
}
|
||||
else
|
||||
{
|
||||
push_down(u,l,r);
|
||||
if(op==1) add[u]=(add[u]+c)%mod;
|
||||
else mul[u]=mul[u]*c%mod;
|
||||
}
|
||||
}
|
||||
return ;
|
||||
}
|
||||
push_down(u,l,r);
|
||||
int mid=(l+r)>>1;
|
||||
if(tr<=mid) Update(lz,tl,tr,c,op);
|
||||
else if(tl>mid) Update(rz,tl,tr,c,op);
|
||||
else
|
||||
{
|
||||
Update(lz,tl,mid,c,op);
|
||||
Update(rz,mid+1,tr,c,op);
|
||||
}
|
||||
}
|
||||
lld Query(int u, int l, int r, int tl, int tr, int p)
|
||||
{
|
||||
if(tl<=l&&r<=tr)
|
||||
{
|
||||
if(ch[u])
|
||||
{
|
||||
lld ans=1, tp=sum[u];
|
||||
for(int i=1; i<=p; i++) ans=ans*tp%mod;
|
||||
return (r-l+1)*ans%mod;
|
||||
}
|
||||
}
|
||||
push_down(u,l,r);
|
||||
int mid=(l+r)>>1;
|
||||
if(tr<=mid) return Query(lz,tl,tr,p);
|
||||
else if(tl>mid) return Query(rz,tl,tr,p);
|
||||
else
|
||||
{
|
||||
lld t1=Query(lz,tl,mid,p);
|
||||
lld t2=Query(rz,mid+1,tr,p);
|
||||
return (t1+t2)%mod;
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int n, m;
|
||||
while(cin >> n >> m, n+m)
|
||||
{
|
||||
build(1,1,n);
|
||||
for(int i=1; i<=m; i++)
|
||||
{
|
||||
int l, r, c, op;
|
||||
scanf("%d%d%d%d",&op,&l,&r,&c);
|
||||
if(op<=3) Update(1,1,n,l,r,c,op);
|
||||
else printf("%I64d\n",Query(1,1,n,l,r,c)%mod);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,76 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
#include <vector>
|
||||
#include <queue>
|
||||
#include <set>
|
||||
#include <map>
|
||||
#include <string>
|
||||
#include <math.h>
|
||||
#include <stdlib.h>
|
||||
using namespace std;
|
||||
const int MAXN = 50010;
|
||||
double c[MAXN][10];
|
||||
double p[MAXN][20];
|
||||
double a[MAXN][10];
|
||||
double b[MAXN];
|
||||
double dp[MAXN];
|
||||
int main()
|
||||
{
|
||||
int n,m;
|
||||
while( scanf("%d%d",&n,&m) == 2 )
|
||||
{
|
||||
if(n == 0 && m == 0)break;
|
||||
for(int i = 1;i <= n;i++)
|
||||
for(int j = 1;j <= m;j++)
|
||||
scanf("%lf",&c[i][j]);
|
||||
for(int i = 1;i < n;i++)
|
||||
{
|
||||
double sum = 0;
|
||||
for(int j = 1;j <= m;j++)
|
||||
sum += c[i][j];
|
||||
double s = 0;
|
||||
for(int j = 1;j <= m && i-j >= 1;j++)
|
||||
{
|
||||
p[i][m-j] = 0.3*c[i][j]/(1+sum);
|
||||
s += p[i][m-j];
|
||||
}
|
||||
for(int j = 1;j <= m && i+j <= n;j++)
|
||||
{
|
||||
p[i][m+j] = 0.7*c[i][j]/(1+sum);
|
||||
s += p[i][m+j];
|
||||
}
|
||||
p[i][m] = -s;
|
||||
b[i] = -1;
|
||||
}
|
||||
for(int i = 1;i <= m+1 && i <= n;i++)
|
||||
a[1][i] = p[1][m+i-1];
|
||||
for(int i = 2;i < n;i++)
|
||||
{
|
||||
int end = min(i+m,n);
|
||||
int start = max(1,i-m);
|
||||
for(int j = start;j < i;j++)
|
||||
if(fabs(p[i][m+j-i]) > 1e-6)
|
||||
{
|
||||
double t = p[i][m+j-i]/a[j][1];
|
||||
for(int k = 1; k <= m+1 && j+k-1 <= n ;k++)
|
||||
{
|
||||
p[i][m+j-i+k-1] -= t*a[j][k];
|
||||
}
|
||||
b[i] -= t*b[j];
|
||||
}
|
||||
for(int j = 1;j <= end-i+1;j++)
|
||||
a[i][j] = p[i][m+j-1];
|
||||
}
|
||||
dp[n] = 0;
|
||||
for(int i = n-1;i >= 1;i--)
|
||||
{
|
||||
for(int j = 2;j <= m+1 && i+j-1 <= n;j++)
|
||||
b[i] -= dp[i+j-1] * a[i][j];
|
||||
dp[i] = b[i]/a[i][1];
|
||||
}
|
||||
printf("%.2f\n",dp[1]);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,51 @@
|
|||
#include <bitset>
|
||||
#include <iostream>
|
||||
using namespace std;
|
||||
const int maxn=2013;
|
||||
int first[maxn],pre[maxn],vv[maxn*20],nxt[maxn*20];
|
||||
bitset<2001> to[2001];
|
||||
bool vis[maxn];
|
||||
int ans;
|
||||
void dfs(int u,int p)
|
||||
{
|
||||
vis[u]=true;
|
||||
to[u].reset();
|
||||
for(int e=pre[u];e;e=nxt[e]) if(vis[vv[e]])
|
||||
to[u].set(vv[e]);
|
||||
for(int e=first[u];e;e=nxt[e]) if(vv[e]!=p)
|
||||
dfs(vv[e],u);
|
||||
if(p==-1)
|
||||
return;
|
||||
if(to[u].test(p))
|
||||
ans++;
|
||||
else
|
||||
to[p]|=to[u];
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int n,m;
|
||||
while(~scanf("%d%d",&n,&m) && n|m)
|
||||
{
|
||||
memset(vis,0,sizeof(vis));
|
||||
memset(first,0,sizeof(first));
|
||||
memset(pre,0,sizeof(pre));
|
||||
int e=2;
|
||||
for(int i=1;i<n;i++)
|
||||
{
|
||||
int u,v;
|
||||
scanf("%d%d",&u,&v);
|
||||
nxt[e]=first[u],vv[e]=v,first[u]=e++;
|
||||
nxt[e]=first[v],vv[e]=u,first[v]=e++;
|
||||
}
|
||||
for(int i=n;i<=m;i++)
|
||||
{
|
||||
int u,v;
|
||||
scanf("%d%d",&u,&v);
|
||||
nxt[e]=pre[u],vv[e]=v,pre[u]=e++;
|
||||
nxt[e]=pre[v],vv[e]=u,pre[v]=e++;
|
||||
}
|
||||
ans=0;
|
||||
dfs(1,-1);
|
||||
printf("%d\n",ans);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,60 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <bitset>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
#define LL long long
|
||||
#define Bool bitset<maxn>
|
||||
const int maxn=60;
|
||||
int a[maxn];
|
||||
Bool to[maxn];
|
||||
LL num[maxn];
|
||||
LL ans;
|
||||
bool gcd(int a,int b)
|
||||
{
|
||||
return b==0?a!=1:gcd(b,a%b);
|
||||
}
|
||||
LL DFS(int n,Bool p)
|
||||
{
|
||||
if(n==-1)
|
||||
return 1;
|
||||
LL res=DFS(n-1,p);
|
||||
if(p.test(n))
|
||||
return res;
|
||||
if((p|to[n])==p)
|
||||
return res*num[n];
|
||||
else
|
||||
return res+DFS(n-1,(p|to[n]))*(num[n]-1);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int n;
|
||||
while(~scanf("%d",&n) && n)
|
||||
{
|
||||
for(int i=0;i<n;i++)
|
||||
scanf("%d",a+i);
|
||||
sort(a,a+n);
|
||||
int m=0;
|
||||
num[0]=2;
|
||||
for(int i=1;i<n;i++)
|
||||
{
|
||||
if(a[i]==a[m])
|
||||
num[m]++;
|
||||
else
|
||||
{
|
||||
a[++m]=a[i];
|
||||
num[m]=2;
|
||||
}
|
||||
}
|
||||
for(int i=0;i<=m;i++)
|
||||
{
|
||||
to[i].reset();
|
||||
for(int j=0;j<i;j++)
|
||||
if(gcd(a[j],a[i]))
|
||||
to[i].set(j);
|
||||
}
|
||||
ans=0;
|
||||
Bool p;
|
||||
printf("%I64d\n",DFS(m,p));
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,58 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
#include <vector>
|
||||
#include <queue>
|
||||
#include <set>
|
||||
#include <map>
|
||||
#include <string>
|
||||
#include <math.h>
|
||||
#include <stdlib.h>
|
||||
using namespace std;
|
||||
struct Point
|
||||
{
|
||||
int x,y;
|
||||
Point(int _x = 0,int _y = 0)
|
||||
{
|
||||
x = _x; y = _y;
|
||||
}
|
||||
};
|
||||
int dis(Point a,Point b)
|
||||
{
|
||||
return abs(a.x-b.x)+abs(a.y-b.y);
|
||||
}
|
||||
Point p1[2000];
|
||||
Point p2[2000];
|
||||
char str[50][50];
|
||||
int main()
|
||||
{
|
||||
int n,m;
|
||||
while(scanf("%d%d",&n,&m) == 2)
|
||||
{
|
||||
if(n == 0 && m == 0)break;
|
||||
for(int i = 0;i < n;i++)
|
||||
scanf("%s",str[i]);
|
||||
int uN = 0, vN = 0;
|
||||
for(int i = 0;i < n;i++)
|
||||
for(int j = 0;j < m;j++)
|
||||
{
|
||||
if(str[i][j] == 'H')p1[uN++] = Point(i,j);
|
||||
else if(str[i][j] == 'C') p2[vN++] = Point(i,j);
|
||||
}
|
||||
int ans1 = 0,ans2 = 0;
|
||||
int Min = 100000000;
|
||||
for(int i = 0;i < uN;i++)
|
||||
for(int j = 0;j < vN;j++)
|
||||
{
|
||||
if(dis(p1[i],p2[j]) < Min)
|
||||
{
|
||||
Min = dis(p1[i],p2[j]);
|
||||
ans1 = i;
|
||||
ans2 = j;
|
||||
}
|
||||
}
|
||||
printf("%d %d %d %d\n",p1[ans1].x,p1[ans1].y,p2[ans2].x,p2[ans2].y);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,28 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <algorithm>
|
||||
#include <map>
|
||||
using namespace std;
|
||||
int main()
|
||||
{
|
||||
int n, id, p;
|
||||
while(cin >> n,n)
|
||||
{
|
||||
map<int,int>mp;
|
||||
mp[1000000000]=1;
|
||||
for(int i=1; i<=n; i++)
|
||||
{
|
||||
scanf("%d%d",&id,&p);
|
||||
map<int,int>::iterator it=mp.lower_bound(p);
|
||||
if(it==mp.begin()) cout << id << " " << it->second <<endl;
|
||||
else
|
||||
{
|
||||
map<int,int>::iterator a=it, b=--it;
|
||||
if((a->first)-p>=p-(b->first))cout << id << " " << b->second <<endl;
|
||||
else cout << id << " " << a->second <<endl;
|
||||
}
|
||||
mp[p]=id;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,53 @@
|
|||
#include <stdio.h>
|
||||
#include <iostream>
|
||||
#include <map>
|
||||
#include <stack>
|
||||
#include <vector>
|
||||
#include <math.h>
|
||||
#include <string.h>
|
||||
#include <queue>
|
||||
#include <string>
|
||||
#include <stdlib.h>
|
||||
#include <algorithm>
|
||||
#define LL long long
|
||||
#define _LL __int64
|
||||
#define eps 1e-8
|
||||
#define PI acos(-1.0)
|
||||
using namespace std;
|
||||
int n,m;
|
||||
int vis[210];
|
||||
int a[210];
|
||||
int sum,cnt;
|
||||
double p,q;
|
||||
int main()
|
||||
{
|
||||
while(~scanf("%d",&n))
|
||||
{
|
||||
sum = 0;
|
||||
cnt = 0;
|
||||
memset(vis,0,sizeof(vis));
|
||||
for(int i = 1; i <= n; i++)
|
||||
{
|
||||
cin >> a[i];
|
||||
sum += a[i];
|
||||
}
|
||||
p = (sum*1.0)/n;
|
||||
scanf("%d",&m);
|
||||
int x;
|
||||
for(int i = 1; i <= m; i++)
|
||||
{
|
||||
cin >> x;
|
||||
if(vis[x]) continue;
|
||||
cnt++;
|
||||
vis[x] = 1;
|
||||
}
|
||||
q = (cnt*1.0)/n;
|
||||
if(fabs(p) < eps)
|
||||
cout << "0.00" << endl;
|
||||
else if(fabs(q-1) < eps)
|
||||
cout << "inf" << endl;
|
||||
else
|
||||
printf("%.2lf\n",p/(1-q));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,70 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<algorithm>
|
||||
#include<stack>
|
||||
using namespace std;
|
||||
#define MAXN 5555
|
||||
struct Edge{
|
||||
int v,next;
|
||||
}edge[MAXN*MAXN];
|
||||
int n,m,NE;
|
||||
int head[MAXN];
|
||||
void Insert(int u,int v)
|
||||
{
|
||||
edge[NE].v=v;
|
||||
edge[NE].next=head[u];
|
||||
head[u]=NE++;
|
||||
}
|
||||
int cnt,rt_son,block;
|
||||
int low[MAXN],dfn[MAXN];
|
||||
int blocks[MAXN];
|
||||
bool mark[MAXN];
|
||||
void Tarjan(int u,int vv)
|
||||
{
|
||||
low[u]=dfn[u]=++cnt;
|
||||
mark[u]=true;
|
||||
for(int i=head[u];i!=-1;i=edge[i].next){
|
||||
int v=edge[i].v;
|
||||
if(v==vv)continue;
|
||||
if(dfn[v]==0){
|
||||
Tarjan(v,vv);
|
||||
low[u]=min(low[u],low[v]);
|
||||
if(low[v]>=dfn[u]){
|
||||
blocks[u]++;
|
||||
}
|
||||
}else if(mark[v]){
|
||||
low[u]=min(low[u],dfn[v]);
|
||||
}
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int u,v,ans;
|
||||
while(~scanf("%d%d",&n,&m)){
|
||||
NE=0;
|
||||
memset(head,-1,sizeof(head));
|
||||
while(m--){
|
||||
scanf("%d%d",&u,&v);
|
||||
Insert(u,v);
|
||||
Insert(v,u);
|
||||
}
|
||||
ans=0;
|
||||
for(int u=0;u<n;u++){
|
||||
memset(mark,false,sizeof(mark));
|
||||
memset(dfn,0,sizeof(dfn));
|
||||
fill(blocks,blocks+n,1);
|
||||
cnt=block=0;
|
||||
for(int v=0;v<n;v++)if(u!=v&&!mark[v]){
|
||||
block++;
|
||||
blocks[v]=0;
|
||||
Tarjan(v,u);
|
||||
}
|
||||
for(int v=0;v<n;v++)if(v!=u){
|
||||
ans=max(ans,block+blocks[v]-1);
|
||||
}
|
||||
}
|
||||
printf("%d\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,44 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <iostream>
|
||||
using namespace std;
|
||||
typedef long long ll;
|
||||
const int N = 40;
|
||||
ll ti[N], p[N], q[N];
|
||||
void cat (ll x, ll* a) {
|
||||
if (x <= 0) return;
|
||||
ll ans = 0, s = 0;
|
||||
for (int i = 0; i <= 32; i++) {
|
||||
ll t = ti[i+1];
|
||||
ll c = x/t, d = x%t;
|
||||
d -= ti[i];
|
||||
a[i] = c * ti[i] + (d <= 0 ? 0 : d);
|
||||
}
|
||||
}
|
||||
ll solve () {
|
||||
ll ans = 0, s = 0;
|
||||
for (int i = 0; i <= 32; i++) {
|
||||
s = s + p[i] - q[i];
|
||||
s /= 2;
|
||||
ans += s;
|
||||
}
|
||||
while (s) {
|
||||
s /= 2;
|
||||
ans += s;
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
int main () {
|
||||
ti[0] = 1;
|
||||
for (int i = 1; i <= 35; i++)
|
||||
ti[i] = ti[i-1] * 2;
|
||||
ll a, b;
|
||||
while (cin >> a >> b) {
|
||||
memset(p, 0, sizeof(p));
|
||||
memset(q, 0, sizeof(q));
|
||||
cat (b+1, p);
|
||||
cat (a, q);
|
||||
cout << solve () << endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,27 @@
|
|||
#include <iostream>
|
||||
#include <cstdlib>
|
||||
#include <cstdio>
|
||||
#include <algorithm>
|
||||
#include <iostream>
|
||||
#include <cstring>
|
||||
using namespace std;
|
||||
const int maxn = 10010;
|
||||
int cnt[maxn];
|
||||
int main()
|
||||
{
|
||||
int n;
|
||||
while(scanf("%d", &n) == 1)
|
||||
{
|
||||
memset(cnt, 0, sizeof(cnt));
|
||||
int ans = -1;
|
||||
for(int i = 0; i < n+1; i++)
|
||||
{
|
||||
int tmp;
|
||||
scanf("%d", &tmp);
|
||||
cnt[tmp]++;
|
||||
if(cnt[tmp] >= 2)
|
||||
ans = tmp;
|
||||
}
|
||||
printf("%d\n", ans);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,210 @@
|
|||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<iostream>
|
||||
#include<algorithm>
|
||||
#include<map>
|
||||
#include<iostream>
|
||||
#include<string>
|
||||
using namespace std;
|
||||
typedef long long ll;
|
||||
int T,t,n,m;
|
||||
map<string,string> match[4];
|
||||
char str[1010],str2[1010],s1[1010],s2[1010];
|
||||
int type1,type2,Err,Over;
|
||||
void init()
|
||||
{
|
||||
int i,j,k;
|
||||
for(i=0;i<=3;i++)
|
||||
match[i].clear();
|
||||
Err=1;
|
||||
Over=0;
|
||||
}
|
||||
bool Has_Equal()
|
||||
{
|
||||
int i,j,k,len=strlen(str);
|
||||
bool flag=0,flag2=0;
|
||||
for(i=0;i<len;i++)
|
||||
{
|
||||
if(str[i]==34)
|
||||
flag2=1;
|
||||
if(str[i]=='=' && flag2==0)
|
||||
{
|
||||
flag=true;
|
||||
str[i]=' ';
|
||||
}
|
||||
if(str[i]==9)
|
||||
str[i]=32;
|
||||
}
|
||||
return flag;
|
||||
}
|
||||
bool kong()
|
||||
{
|
||||
int i,j,k,len=strlen(str);
|
||||
bool flag=0;
|
||||
for(i=0;i<len;i++)
|
||||
if(!(str[i]==' ' || str[i]==9))
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
void solve()
|
||||
{
|
||||
int i,j,k,len=strlen(str);
|
||||
m=0;
|
||||
for(i=0;i<len;i++)
|
||||
if(str[i]==34)
|
||||
break;
|
||||
m=i;
|
||||
for(i=m;i<len;i++)
|
||||
if(!(str[i]==' ' || str[i]==9))
|
||||
str[m++]=str[i];
|
||||
str[m]='\0';
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int i,j,k,pos;
|
||||
string string1,string2;
|
||||
scanf("%d",&T);
|
||||
for(t=1;t<=T;t++)
|
||||
{
|
||||
if(t!=1)
|
||||
printf("\n");
|
||||
scanf("%d",&n);
|
||||
getchar();
|
||||
init();
|
||||
while(n--)
|
||||
{
|
||||
gets(str);
|
||||
solve();
|
||||
if(Over==1)
|
||||
continue;
|
||||
if(kong())
|
||||
continue;
|
||||
if(Has_Equal())
|
||||
{
|
||||
sscanf(str,"%s %s",s1,s2);
|
||||
if(s1[0]=='$')
|
||||
type1=0;
|
||||
else
|
||||
type1=1;
|
||||
if(s2[0]!=34)
|
||||
type2=0;
|
||||
else
|
||||
type2=1;
|
||||
if(type1==0)
|
||||
{
|
||||
match[0].erase(s1);
|
||||
match[1].erase(s1);
|
||||
match[type2][s1]=s2;
|
||||
}
|
||||
else
|
||||
{
|
||||
if(match[2].find(s1)==match[2].end() && match[3].find(s1)==match[3].end())
|
||||
match[2+type2][s1]=s2;
|
||||
else if(Err==1)
|
||||
printf("WARNING: Constant %s Already Defined!\n",s1);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
sscanf(str,"%s %s",s1,s2);
|
||||
if(s1[0]=='P' && s1[1]=='a') //Panic
|
||||
{
|
||||
printf("Script was KILLED.\n");
|
||||
Over=1;
|
||||
}
|
||||
else if(s1[0]=='E' && s2[1]=='N') //Errmsg ON
|
||||
Err=1;
|
||||
else if(s1[0]=='E' && s2[1]=='F') //Errmsg OFF
|
||||
Err=0;
|
||||
else if(s1[0]=='P') //Print
|
||||
{
|
||||
if(s2[0]=='$')
|
||||
{
|
||||
if(match[0].find(s2)!=match[0].end())
|
||||
{
|
||||
string1=match[0][s2];
|
||||
cout<<string1<<endl;
|
||||
}
|
||||
else if(match[1].find(s2)!=match[1].end())
|
||||
{
|
||||
string1=match[1][s2];
|
||||
string2=string1.substr(1,string1.length()-2);
|
||||
cout<<string2<<endl;
|
||||
}
|
||||
else
|
||||
{
|
||||
printf("NULL\n");
|
||||
if(Err==1)
|
||||
printf("NOTICE: Undefined Variable %s.\n",s2);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if(match[2].find(s2)!=match[2].end())
|
||||
{
|
||||
string1=match[2][s2];
|
||||
cout<<string1<<endl;
|
||||
}
|
||||
else if(match[3].find(s2)!=match[3].end())
|
||||
{
|
||||
string1=match[3][s2];
|
||||
string2=string1.substr(1,string1.length()-2);
|
||||
cout<<string2<<endl;
|
||||
}
|
||||
else
|
||||
{
|
||||
printf("%s\n",s2);
|
||||
if(Err==1)
|
||||
printf("NOTICE: Undefined Constant %s.\n",s2);
|
||||
}
|
||||
}
|
||||
}
|
||||
else if(s1[0]=='D') //Dump
|
||||
{
|
||||
if(s2[0]=='$')
|
||||
{
|
||||
if(match[0].find(s2)!=match[0].end())
|
||||
{
|
||||
string1=match[0][s2];
|
||||
printf("integer: ");
|
||||
cout<<string1<<endl;
|
||||
}
|
||||
else if(match[1].find(s2)!=match[1].end())
|
||||
{
|
||||
string1=match[1][s2];
|
||||
printf("string: ");
|
||||
cout<<string1<<endl;
|
||||
}
|
||||
else
|
||||
{
|
||||
printf("NULL\n");
|
||||
if(Err==1)
|
||||
printf("NOTICE: Undefined Variable %s.\n",s2);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if(match[2].find(s2)!=match[2].end())
|
||||
{
|
||||
string1=match[2][s2];
|
||||
printf("integer: ");
|
||||
cout<<string1<<endl;
|
||||
}
|
||||
else if(match[3].find(s2)!=match[3].end())
|
||||
{
|
||||
string1=match[3][s2];
|
||||
printf("string: ");
|
||||
cout<<string1<<endl;
|
||||
}
|
||||
else
|
||||
{
|
||||
printf("string: %c%s%c\n",34,s2,34);
|
||||
if(Err==1)
|
||||
printf("NOTICE: Undefined Constant %s.\n",s2);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,67 @@
|
|||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<map>
|
||||
#include<string>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
typedef long long ll;
|
||||
map<string,int> match;
|
||||
char s[100010][20];
|
||||
int n,m,point[100010],one[100010],two[100010],sum_one[100010],sum_two[100010];
|
||||
bool cmp(char a,char b)
|
||||
{
|
||||
return a<b;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int i,j,k,a,b,len,c,pos;
|
||||
ll l,r,ans;
|
||||
while(~scanf("%d%d",&n,&m))
|
||||
{
|
||||
for(i=1;i<=n;i++)
|
||||
scanf("%s",s[i]);
|
||||
match.clear();
|
||||
for(i=n;i>=1;i--)
|
||||
{
|
||||
len=strlen(s[i]);
|
||||
sort(s[i],s[i]+len,cmp);
|
||||
k=match[s[i]];
|
||||
if(k==0)
|
||||
point[i]=n+1;
|
||||
else
|
||||
point[i]=k;
|
||||
match[s[i]]=i;
|
||||
}
|
||||
a=n+1;b=n+1;
|
||||
for(i=n;i>=1;i--)
|
||||
{
|
||||
c=point[i];
|
||||
if(c<a)
|
||||
b=a,a=c;
|
||||
else if(c<b)
|
||||
b=c;
|
||||
one[i]=a;
|
||||
two[i]=b;
|
||||
}
|
||||
for(i=1;i<=n;i++)
|
||||
{
|
||||
sum_one[i]=sum_one[i-1]+(one[i]-1);
|
||||
sum_two[i]=sum_two[i-1]+(two[i]-1);
|
||||
}
|
||||
ans=0;
|
||||
while(m--)
|
||||
{
|
||||
scanf("%I64d%I64d",&l,&r);
|
||||
l+=ans;
|
||||
r-=ans;
|
||||
ans=0;
|
||||
pos=upper_bound(one+1,one+n,r)-one-1;
|
||||
if(pos>=l)
|
||||
ans+=r*(pos-l+1)-(sum_one[pos]-sum_one[l-1]);
|
||||
pos=upper_bound(two+1,two+n,r)-two-1;
|
||||
if(pos>=l)
|
||||
ans-=r*(pos-l+1)-(sum_two[pos]-sum_two[l-1]);
|
||||
printf("%I64d\n",ans);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,55 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
using namespace std;
|
||||
#define maxn 100001
|
||||
#define Max(a,b) (a)>(b)?(a):(b)
|
||||
#define Min(a,b) (a)<(b)?(a):(b)
|
||||
struct Node
|
||||
{
|
||||
int x,y,z;
|
||||
}node[1005];
|
||||
int gcd(int a,int b)
|
||||
{
|
||||
if(b==0) return a;
|
||||
else return gcd(b,a%b);
|
||||
}
|
||||
int check2(int d,int l,int r)
|
||||
{
|
||||
if(l%d==0 || r%d==0) return 1;
|
||||
else if(r/d>l/d) return 1;
|
||||
else return 0;
|
||||
}
|
||||
int check(int i,int j)
|
||||
{
|
||||
if(node[i].y>node[j].z || node[j].y>node[i].z)
|
||||
{
|
||||
if(node[i].y>node[i].z) swap(i,j);
|
||||
int d=gcd(node[i].x,node[j].x);
|
||||
if(check2(d,node[j].y-node[i].z,node[j].z-node[i].y))
|
||||
return 1;
|
||||
else
|
||||
return 0;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
int main(){
|
||||
int n,i,j;
|
||||
while(~scanf("%d",&n))
|
||||
{
|
||||
for(i=1;i<=n;i++)
|
||||
scanf("%d %d %d",&node[i].x,&node[i].y,&node[i].z);
|
||||
int flag=0;
|
||||
for(i=1;i<=n;i++)
|
||||
{
|
||||
for(j=i+1;j<=n;j++)
|
||||
{
|
||||
if(check(i,j)) {flag=1;break;}
|
||||
}
|
||||
if(flag) break;
|
||||
}
|
||||
if(!flag)printf("Can Take off\n");
|
||||
else printf("Cannot Take off\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,64 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
#include <vector>
|
||||
#include <queue>
|
||||
#include <set>
|
||||
#include <map>
|
||||
#include <string>
|
||||
#include <math.h>
|
||||
#include <stdlib.h>
|
||||
#include <time.h>
|
||||
using namespace std;
|
||||
int a[30],b[30];
|
||||
int sum1[30];
|
||||
int sum2[30];
|
||||
int dp[30][30][30][30];
|
||||
int solve(int l1,int r1,int l2,int r2)
|
||||
{
|
||||
if(dp[l1][r1][l2][r2] != -1)return dp[l1][r1][l2][r2];
|
||||
if(l1 > r1 && l2 > r2)
|
||||
return dp[l1][r1][l2][r2] = 0;
|
||||
int ans = 0;
|
||||
int sum = 0;
|
||||
if(l1 <= r1)
|
||||
sum += sum1[r1] - sum1[l1-1];
|
||||
if(l2 <= r2)
|
||||
sum += sum2[r2] - sum2[l2-1];
|
||||
if(l1 <= r1)
|
||||
{
|
||||
ans = max(ans,sum - solve(l1+1,r1,l2,r2));
|
||||
ans = max(ans,sum - solve(l1,r1-1,l2,r2));
|
||||
}
|
||||
if(l2 <= r2)
|
||||
{
|
||||
ans = max(ans,sum - solve(l1,r1,l2+1,r2));
|
||||
ans = max(ans,sum - solve(l1,r1,l2,r2-1));
|
||||
}
|
||||
return dp[l1][r1][l2][r2] = ans;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int n;
|
||||
int T;
|
||||
scanf("%d",&T);
|
||||
while(T--)
|
||||
{
|
||||
scanf("%d",&n);
|
||||
sum1[0] = sum2[0] = 0;
|
||||
for(int i = 1;i <= n;i++)
|
||||
{
|
||||
scanf("%d",&a[i]);
|
||||
sum1[i] = sum1[i-1] + a[i];
|
||||
}
|
||||
for(int i = 1;i <= n;i++)
|
||||
{
|
||||
scanf("%d",&b[i]);
|
||||
sum2[i] = sum2[i-1] + b[i];
|
||||
}
|
||||
memset(dp,-1,sizeof(dp));
|
||||
printf("%d\n",solve(1,n,1,n));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,129 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<string>
|
||||
#include<cstring>
|
||||
#include<cmath>
|
||||
#include<algorithm>
|
||||
#include<queue>
|
||||
#include<stack>
|
||||
#include<vector>
|
||||
#include<climits>
|
||||
#include<map>
|
||||
using namespace std;
|
||||
#define rep(i,n) for(int i=0; i<n; i++)
|
||||
#define repf(i,n,m) for(int i=(n); i<=(m); ++i)
|
||||
#define repd(i,n,m) for(int i=(n); i>=(m); --i)
|
||||
#define ll long long
|
||||
#define arc(a) ((a)*(a))
|
||||
#define inf 10000000
|
||||
#define exp 0.000001
|
||||
#define N 305
|
||||
#define T 400
|
||||
int cont[N];
|
||||
struct node
|
||||
{
|
||||
int y,w,pre;
|
||||
};
|
||||
node a[N*N];
|
||||
int pre[N];
|
||||
int color[N];
|
||||
bool vis[N];
|
||||
int dp[N];
|
||||
char s[N][N];
|
||||
int n,len;
|
||||
bool dfs(int x)
|
||||
{
|
||||
color[x]=0;
|
||||
queue<int>q; q.push(x);
|
||||
while(!q.empty())
|
||||
{
|
||||
int x=q.front(); q.pop();
|
||||
rep(i,n)
|
||||
if(s[x][i]=='1')
|
||||
if(color[i]==-1)
|
||||
color[i]=color[x]^1,q.push(i);
|
||||
else if(color[i]==color[x])
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
void init()
|
||||
{
|
||||
memset(color,-1,sizeof(color));
|
||||
len=1;
|
||||
memset(pre,-1,sizeof(pre));
|
||||
rep(i,n) dp[i]=inf;
|
||||
memset(cont,0,sizeof(cont));
|
||||
memset(vis,false,sizeof(vis));
|
||||
}
|
||||
void addpage(int s,int t,int w)
|
||||
{
|
||||
a[len].y=t;
|
||||
a[len].w=w;
|
||||
a[len].pre=pre[s];
|
||||
pre[s]=len++;
|
||||
}
|
||||
bool spfa()
|
||||
{
|
||||
queue<int>q;
|
||||
q.push(0);
|
||||
vis[0]=true; dp[0]=0;
|
||||
while(!q.empty())
|
||||
{
|
||||
int x=q.front(); q.pop(); vis[x]=false;
|
||||
for(int i=pre[x]; i!=-1; i=a[i].pre)
|
||||
{
|
||||
int y=a[i].y;
|
||||
if(dp[x]+a[i].w<dp[y])
|
||||
{
|
||||
dp[y]=dp[x]+a[i].w;
|
||||
if(vis[y]==false)
|
||||
{
|
||||
q.push(y);
|
||||
vis[y]=true;
|
||||
cont[y]++;
|
||||
if(cont[y]>n)
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
bool solve()
|
||||
{
|
||||
init();
|
||||
rep(i,n)
|
||||
if(color[i]==-1)
|
||||
if(!dfs(i))
|
||||
return false;
|
||||
rep(i,n)
|
||||
repf(j,i+1,n-1)
|
||||
{
|
||||
if(s[i][j]=='0')
|
||||
if(color[i]==0)
|
||||
addpage(j,i,T-1);
|
||||
else
|
||||
addpage(i,j,T-1);
|
||||
else
|
||||
if(color[i]==0)
|
||||
addpage(i,j,-T);
|
||||
else addpage(j,i,-T);
|
||||
}
|
||||
return spfa();
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int test;
|
||||
scanf("%d",&test);
|
||||
while(test--)
|
||||
{
|
||||
scanf("%d",&n);
|
||||
rep(i,n) scanf("%s",s[i]);
|
||||
if(solve())
|
||||
printf("Yes\n");
|
||||
else
|
||||
printf("No\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,76 @@
|
|||
#include <cstring>
|
||||
#include <iostream>
|
||||
#include <cmath>
|
||||
#include <algorithm>
|
||||
#include <cstdio>
|
||||
using namespace std;
|
||||
typedef long long LL;
|
||||
using namespace std;
|
||||
LL n;
|
||||
LL mod =2011;
|
||||
LL exgcd(LL a,LL b,LL &x,LL &y)
|
||||
{
|
||||
if(b==0)
|
||||
{
|
||||
x=1;
|
||||
y=0;
|
||||
return a;
|
||||
}
|
||||
else
|
||||
{
|
||||
LL ans=exgcd(b,a%b,x,y);
|
||||
LL tmp=x;
|
||||
x=y;
|
||||
y=tmp-a/b*y;
|
||||
return ans;
|
||||
}
|
||||
}
|
||||
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;
|
||||
}
|
||||
LL solve0(LL n)
|
||||
{
|
||||
LL ans=Pow(6,n%2010,2011);
|
||||
ans+=24;
|
||||
ans%=mod;
|
||||
LL x,y;
|
||||
exgcd(30,mod,x,y);
|
||||
LL niyuan=(x%mod+mod)%mod;
|
||||
ans=(ans*niyuan)%mod;
|
||||
return ans;
|
||||
}
|
||||
LL solve(LL n)
|
||||
{
|
||||
LL ans=Pow(6,n%2010,2011);
|
||||
ans=(ans+2010)%mod;
|
||||
LL x,y;
|
||||
exgcd(5,mod,x,y);
|
||||
LL niyuan=(x%mod+mod)%mod;
|
||||
ans=(ans*niyuan)%mod;
|
||||
return ans;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
while(scanf("%I64d",&n)!=EOF)
|
||||
{
|
||||
if(n==0)
|
||||
break;
|
||||
printf("%I64d %I64d\n",solve0(n),solve(n));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
Loading…
Reference in New Issue