From a34c4631446d7b56e71756e683832c973880ef83 Mon Sep 17 00:00:00 2001 From: KiritoTRw <3021577574@qq.com> Date: Tue, 6 Sep 2016 13:31:25 +0800 Subject: [PATCH] Powered By HC TECH : AutoACer Engine 4400-4499 --- HDOJ/4400_autoAC.cpp | 96 +++++++++ HDOJ/4401_autoAC.cpp | 111 +++++++++++ HDOJ/4403_autoAC.cpp | 60 ++++++ HDOJ/4404_autoAC.cpp | 69 +++++++ HDOJ/4405_autoAC.cpp | 59 ++++++ HDOJ/4406_autoAC.cpp | 142 ++++++++++++++ HDOJ/4407_autoAC.cpp | 98 ++++++++++ HDOJ/4408_autoAC.cpp | 125 ++++++++++++ HDOJ/4409_autoAC.cpp | 144 ++++++++++++++ HDOJ/4410_autoAC.cpp | 168 ++++++++++++++++ HDOJ/4411_autoAC.cpp | 127 ++++++++++++ HDOJ/4412_autoAC.cpp | 78 ++++++++ HDOJ/4413_autoAC.cpp | 136 +++++++++++++ HDOJ/4414_autoAC.cpp | 90 +++++++++ HDOJ/4415_autoAC.cpp | 112 +++++++++++ HDOJ/4416_autoAC.cpp | 100 ++++++++++ HDOJ/4417_autoAC.cpp | 71 +++++++ HDOJ/4418_autoAC.cpp | 109 +++++++++++ HDOJ/4419_autoAC.cpp | 119 ++++++++++++ HDOJ/4421_autoAC.cpp | 111 +++++++++++ HDOJ/4422_autoAC.cpp | 71 +++++++ HDOJ/4424_autoAC.cpp | 63 ++++++ HDOJ/4426_autoAC.cpp | 200 +++++++++++++++++++ HDOJ/4427_autoAC.cpp | 68 +++++++ HDOJ/4429_autoAC.cpp | 170 ++++++++++++++++ HDOJ/4430_autoAC.cpp | 50 +++++ HDOJ/4431_autoAC.cpp | 132 +++++++++++++ HDOJ/4432_autoAC.cpp | 53 +++++ HDOJ/4433_autoAC.cpp | 58 ++++++ HDOJ/4435_autoAC.cpp | 94 +++++++++ HDOJ/4436_autoAC.cpp | 95 +++++++++ HDOJ/4438_autoAC.cpp | 21 ++ HDOJ/4439_autoAC.cpp | 104 ++++++++++ HDOJ/4441_autoAC.cpp | 405 ++++++++++++++++++++++++++++++++++++++ HDOJ/4442_autoAC.cpp | 35 ++++ HDOJ/4443_autoAC.cpp | 453 +++++++++++++++++++++++++++++++++++++++++++ HDOJ/4444_autoAC.cpp | 161 +++++++++++++++ HDOJ/4445_autoAC.cpp | 37 ++++ HDOJ/4446_autoAC.cpp | 127 ++++++++++++ HDOJ/4447_autoAC.cpp | 124 ++++++++++++ HDOJ/4449_autoAC.cpp | 323 ++++++++++++++++++++++++++++++ HDOJ/4450_autoAC.cpp | 12 ++ HDOJ/4451_autoAC.cpp | 31 +++ HDOJ/4452_autoAC.cpp | 129 ++++++++++++ HDOJ/4453_autoAC.cpp | 207 ++++++++++++++++++++ HDOJ/4454_autoAC.cpp | 90 +++++++++ HDOJ/4455_autoAC.cpp | 56 ++++++ HDOJ/4456_autoAC.cpp | 82 ++++++++ HDOJ/4458_autoAC.cpp | 102 ++++++++++ HDOJ/4459_autoAC.cpp | 218 +++++++++++++++++++++ HDOJ/4460_autoAC.cpp | 77 ++++++++ HDOJ/4462_autoAC.cpp | 76 ++++++++ HDOJ/4463_autoAC.cpp | 70 +++++++ HDOJ/4464_autoAC.cpp | 19 ++ HDOJ/4465_autoAC.cpp | 30 +++ HDOJ/4466_autoAC.cpp | 75 +++++++ HDOJ/4467_autoAC.cpp | 99 ++++++++++ HDOJ/4468_autoAC.cpp | 77 ++++++++ HDOJ/4471_autoAC.cpp | 94 +++++++++ HDOJ/4472_autoAC.cpp | 25 +++ HDOJ/4473_autoAC.cpp | 38 ++++ HDOJ/4474_autoAC.cpp | 62 ++++++ HDOJ/4475_autoAC.cpp | 26 +++ HDOJ/4476_autoAC.cpp | 60 ++++++ HDOJ/4477_autoAC.cpp | 34 ++++ HDOJ/4478_autoAC.cpp | 81 ++++++++ HDOJ/4479_autoAC.cpp | 60 ++++++ HDOJ/4483_autoAC.cpp | 52 +++++ HDOJ/4484_autoAC.cpp | 30 +++ HDOJ/4485_autoAC.cpp | 26 +++ HDOJ/4486_autoAC.cpp | 25 +++ HDOJ/4487_autoAC.cpp | 42 ++++ HDOJ/4488_autoAC.cpp | 66 +++++++ HDOJ/4489_autoAC.cpp | 43 ++++ HDOJ/4490_autoAC.cpp | 149 ++++++++++++++ HDOJ/4491_autoAC.cpp | 109 +++++++++++ HDOJ/4492_autoAC.cpp | 32 +++ HDOJ/4493_autoAC.cpp | 38 ++++ HDOJ/4494_autoAC.cpp | 151 +++++++++++++++ HDOJ/4495_autoAC.cpp | 90 +++++++++ HDOJ/4496_autoAC.cpp | 49 +++++ HDOJ/4497_autoAC.cpp | 72 +++++++ HDOJ/4498_autoAC.cpp | 115 +++++++++++ HDOJ/4499_autoAC.cpp | 74 +++++++ 84 files changed, 8062 insertions(+) create mode 100644 HDOJ/4400_autoAC.cpp create mode 100644 HDOJ/4401_autoAC.cpp create mode 100644 HDOJ/4403_autoAC.cpp create mode 100644 HDOJ/4404_autoAC.cpp create mode 100644 HDOJ/4405_autoAC.cpp create mode 100644 HDOJ/4406_autoAC.cpp create mode 100644 HDOJ/4407_autoAC.cpp create mode 100644 HDOJ/4408_autoAC.cpp create mode 100644 HDOJ/4409_autoAC.cpp create mode 100644 HDOJ/4410_autoAC.cpp create mode 100644 HDOJ/4411_autoAC.cpp create mode 100644 HDOJ/4412_autoAC.cpp create mode 100644 HDOJ/4413_autoAC.cpp create mode 100644 HDOJ/4414_autoAC.cpp create mode 100644 HDOJ/4415_autoAC.cpp create mode 100644 HDOJ/4416_autoAC.cpp create mode 100644 HDOJ/4417_autoAC.cpp create mode 100644 HDOJ/4418_autoAC.cpp create mode 100644 HDOJ/4419_autoAC.cpp create mode 100644 HDOJ/4421_autoAC.cpp create mode 100644 HDOJ/4422_autoAC.cpp create mode 100644 HDOJ/4424_autoAC.cpp create mode 100644 HDOJ/4426_autoAC.cpp create mode 100644 HDOJ/4427_autoAC.cpp create mode 100644 HDOJ/4429_autoAC.cpp create mode 100644 HDOJ/4430_autoAC.cpp create mode 100644 HDOJ/4431_autoAC.cpp create mode 100644 HDOJ/4432_autoAC.cpp create mode 100644 HDOJ/4433_autoAC.cpp create mode 100644 HDOJ/4435_autoAC.cpp create mode 100644 HDOJ/4436_autoAC.cpp create mode 100644 HDOJ/4438_autoAC.cpp create mode 100644 HDOJ/4439_autoAC.cpp create mode 100644 HDOJ/4441_autoAC.cpp create mode 100644 HDOJ/4442_autoAC.cpp create mode 100644 HDOJ/4443_autoAC.cpp create mode 100644 HDOJ/4444_autoAC.cpp create mode 100644 HDOJ/4445_autoAC.cpp create mode 100644 HDOJ/4446_autoAC.cpp create mode 100644 HDOJ/4447_autoAC.cpp create mode 100644 HDOJ/4449_autoAC.cpp create mode 100644 HDOJ/4450_autoAC.cpp create mode 100644 HDOJ/4451_autoAC.cpp create mode 100644 HDOJ/4452_autoAC.cpp create mode 100644 HDOJ/4453_autoAC.cpp create mode 100644 HDOJ/4454_autoAC.cpp create mode 100644 HDOJ/4455_autoAC.cpp create mode 100644 HDOJ/4456_autoAC.cpp create mode 100644 HDOJ/4458_autoAC.cpp create mode 100644 HDOJ/4459_autoAC.cpp create mode 100644 HDOJ/4460_autoAC.cpp create mode 100644 HDOJ/4462_autoAC.cpp create mode 100644 HDOJ/4463_autoAC.cpp create mode 100644 HDOJ/4464_autoAC.cpp create mode 100644 HDOJ/4465_autoAC.cpp create mode 100644 HDOJ/4466_autoAC.cpp create mode 100644 HDOJ/4467_autoAC.cpp create mode 100644 HDOJ/4468_autoAC.cpp create mode 100644 HDOJ/4471_autoAC.cpp create mode 100644 HDOJ/4472_autoAC.cpp create mode 100644 HDOJ/4473_autoAC.cpp create mode 100644 HDOJ/4474_autoAC.cpp create mode 100644 HDOJ/4475_autoAC.cpp create mode 100644 HDOJ/4476_autoAC.cpp create mode 100644 HDOJ/4477_autoAC.cpp create mode 100644 HDOJ/4478_autoAC.cpp create mode 100644 HDOJ/4479_autoAC.cpp create mode 100644 HDOJ/4483_autoAC.cpp create mode 100644 HDOJ/4484_autoAC.cpp create mode 100644 HDOJ/4485_autoAC.cpp create mode 100644 HDOJ/4486_autoAC.cpp create mode 100644 HDOJ/4487_autoAC.cpp create mode 100644 HDOJ/4488_autoAC.cpp create mode 100644 HDOJ/4489_autoAC.cpp create mode 100644 HDOJ/4490_autoAC.cpp create mode 100644 HDOJ/4491_autoAC.cpp create mode 100644 HDOJ/4492_autoAC.cpp create mode 100644 HDOJ/4493_autoAC.cpp create mode 100644 HDOJ/4494_autoAC.cpp create mode 100644 HDOJ/4495_autoAC.cpp create mode 100644 HDOJ/4496_autoAC.cpp create mode 100644 HDOJ/4497_autoAC.cpp create mode 100644 HDOJ/4498_autoAC.cpp create mode 100644 HDOJ/4499_autoAC.cpp diff --git a/HDOJ/4400_autoAC.cpp b/HDOJ/4400_autoAC.cpp new file mode 100644 index 0000000..63f421a --- /dev/null +++ b/HDOJ/4400_autoAC.cpp @@ -0,0 +1,96 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +const int maxn = 110005; +const int inf = 2000000005; +struct NODE{ + int y, dis; + NODE(){ + } + NODE(int _y, int _dis){ + y = _y; dis = _dis; + } + bool operator <(const NODE &tmp)const{ + if(y == tmp.y) return dis < tmp.dis; + return y < tmp.y; + } +}; +struct POINT{ + int x, y, dis; + POINT() { + } + POINT(int _x, int _y, int _dis){ + x = _x; + y = _y; + dis = _dis; + } +}df[maxn], myque[1111111]; +int n, m, has[maxn], num; +vectormygraph[maxn]; +void init(){ + num = 0; + for(int i = 0; i < maxn; i++) mygraph[i].clear(); +} +void readdata(){ + for(int i = 1; i <= n ; i++){ + scanf("%d%d%d", &df[i].x, &df[i].y, &df[i].dis); + has[num++] = df[i].x; + } + sort(has, has + num); + num = unique(has, has + num) - has; + for(int i = 1; i <= n; i++){ + int id = lower_bound(has, has + num, df[i].x) - has; + mygraph[id].push_back(NODE(df[i].y, df[i].dis)); + } +} +int fuckit(int fuckid){ + int head = 0, tail = 0, ret = 0; + vector::iterator vectoriterator1, vectoriterator2, tmpvectoriterator; + myque[tail++] = POINT(df[fuckid].x, df[fuckid].y, df[fuckid].dis); + while(head < tail){ + POINT now = myque[head++]; + int pos1 = lower_bound(has, has + num, now.x - now.dis) - has; + int pos2 = upper_bound(has, has + num, now.x + now.dis) - has; + for(; pos1 != pos2; pos1++){ + int fucknum = has[pos1]; + int fucky = now.dis - abs(fucknum - now.x); + int id = lower_bound(has, has + num, fucknum) - has; + vectoriterator1 = lower_bound(mygraph[id].begin(), mygraph[id].end(), NODE(now.y - fucky, -1)); + vectoriterator2 = upper_bound(mygraph[id].begin(), mygraph[id].end(), NODE(now.y + fucky, inf)); + tmpvectoriterator = vectoriterator1; + for(; vectoriterator1 != vectoriterator2; vectoriterator1++){ + NODE tmp = *vectoriterator1; + myque[tail++] = POINT(fucknum, tmp.y, tmp.dis); + ret++; + } + mygraph[id].erase(tmpvectoriterator, vectoriterator2); + } + } + return ret; +} +int main(){ + int testcases = 0; + while(scanf("%d", &n) != EOF && n){ + init(); + readdata(); + printf("Case #%d:\n", ++testcases); + for(int i = 0; i < num; i++) { + sort(mygraph[i].begin(), mygraph[i].end()); + } + scanf("%d", &m); + for(int i = 1; i <= m; i++){ + int k; + scanf("%d", &k); + int sum = fuckit(k);; + printf("%d\n", sum); + } + } + return 0; +} diff --git a/HDOJ/4401_autoAC.cpp b/HDOJ/4401_autoAC.cpp new file mode 100644 index 0000000..9b2f486 --- /dev/null +++ b/HDOJ/4401_autoAC.cpp @@ -0,0 +1,111 @@ + #include + #include + #include + #include + #include + #define PI acos(-1.0) + using namespace std; + struct Node + { + double h,x; + }; + Node a[1005],b[1005],st[1005]; + double L; + int n,T1,T2,top; + inline int DB(double x) + { + if(x>1e-10) return 1; + if(x<-1e-10) return -1; + return 0; + } + double cal1(Node a,Node b) + { + double k=(a.h-b.h)/(a.x-b.x); + double x=a.x-a.h/k; + return x; + } + double cal2(double x1,double x2,double h,int t) + { + double a=sqrt(h*h+x2*x2)-sqrt(h*h+x1*x1); + double b=(x2-x1)*cos(PI/12.0*t); + double c=12.0/PI; + return c*(a-b); + } + double cal(double x1,double x2,double h,int t) + { + double B1,B2,B3; + if(DB(x1)==0) B1=PI/2; + else B1=atan(fabs(h/x1)); + B2=atan(fabs(h/x2)); + B3=PI/12*t; + if(DB(B3-B1)>=0) return cal2(x1,x2,h,t); + if(DB(B2-B3)>=0) return 0; + double k=-tan(B3); + return cal2(-h/k,x2,h,t); + } + int OK(Node a,Node b,Node c) + { + double k1=(a.h-b.h)/(a.x-b.x); + double k2=(b.h-c.h)/(b.x-c.x); + if(DB(k1-k2)==-1) return 1; + return 0; + } + double solve(int t,Node a[]) + { + top=0; + st[++top]=a[1]; + double ans=0; + int i,j; + double x1,x2; + for(i=2;i<=n;i++) + { + x1=a[i-1].x; + x2=a[i-1].x; + for(j=top;j>=2;j--) + { + x2=cal1(st[j-1],st[j]); + if(DB(x2-a[i].x)>=0) break; + ans+=cal(x1-st[j].x,x2-st[j].x,st[j].h,t); + x1=x2; + } + ans+=cal(x1-st[j].x,a[i].x-st[j].x,st[j].h,t); + while(top>=2&&OK(st[top-1],st[top],a[i])||top>=1&&DB(a[i].h-st[top].h)>=0) + top--; + st[++top]=a[i]; + } + return ans; + } + int cmp(Node a,Node b) + { + return a.x +#include +#include +#include +using namespace std; +char seq[50]; +char str[50]; +int n,ans,eq; +bool ok(int len) +{ + long long a,sum=0; + int i,flg=1; + queue q; + q.push('+'); + seq[len]='\0'; + for(i=0; i='0'&&seq[i]<='9') a=a*10+seq[i]-'0',i++; + q.push(seq[i]); + if(flg&&q.front()=='+') + sum+=a; + else + flg=0,sum-=a; + q.pop(); + } + if(sum==0) return 1; + else return 0; +} +void dfs(int cur,int q) +{ + if(eq>1) return; + if(q>n) + { + if(ok(cur)) ans++; + return; + } + seq[cur]=str[q]; + dfs(cur+1,q+1); + seq[cur]='+'; + seq[cur+1]=str[q]; + dfs(cur+2,q+1); + seq[cur]='='; + seq[cur+1]=str[q]; + eq++; + dfs(cur+2,q+1); + eq--; +} +int main() +{ + while(cin>>str,str[0]!='E') + { + ans=0;eq=0; + seq[0]=str[0]; + n=strlen(str)-1; + dfs(1,1); + cout< +#include +#include +#include +using namespace std; +const double Pi=acos(-1.0); +const double EP=1e-10; +struct Point{ + double x,y; +}; +double x_mult(Point sp, Point ep, Point op){ + return (sp.x-op.x)*(ep.y-op.y)-(sp.y-op.y)*(ep.x-op.x); +} +double cross(Point a,Point b,Point c){ + return (a.x-c.x)*(b.x-c.x)+(a.y-c.y)*(b.y-c.y); +} +double dist(Point a,Point b){ + return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y)); +} +double cal_area(Point a,Point b,Point c,double r){ + double A,B,C,x,y,tS; + A=dist(b,c); + B=dist(a,c); + C=dist(b,a); + if(A=r){ + x=(cross(a,c,b)+sqrt(r*r*C*C-x_mult(a,c,b)*x_mult(a,c,b)))/C; + tS=x_mult(a,b,c)/2; + return asin(tS*(1-x/C)*2/r/B*(1-EP))*r*r/2+tS*x/C; + } + else if(A>=r&&B=r*C||cross(b,c,a)<=0||cross(a,c,b)<=0){ + if(cross(a,b,c)<0) + if(x_mult(a,b,c)<0) + return (-acos(-1.0)-asin(x_mult(a,b,c)/A/B*(1-EP)))*r*r/2; + else return (acos(-1.0)-asin(x_mult(a,b,c)/A/B*(1-EP)))*r*r/2; + else return asin(x_mult(a,b,c)/A/B*(1-EP))*r*r/2; + } + else{ + x=(cross(a,c,b)+sqrt(r*r*C*C-x_mult(a,c,b)*x_mult(a,c,b)))/C; + y=(cross(b,c,a)+sqrt(r*r*C*C-x_mult(b,c,a)*x_mult(b,c,a)))/C; + tS=x_mult(a,b,c)/2; + return (asin(tS*(1-x/C)*2/r/B*(1-EP))+asin(tS*(1-y/C)*2/r/A*(1-EP)))*r*r/2+tS*((y+x)/C-1); + } +} +int main(){ + Point p[105],cir; + double r,area, x0, y0, v, angle, t, g; + int i, n; + while(scanf("%lf%lf%lf%lf%lf%lf%lf", &x0, &y0, &v, &angle, &t, &g, &r)!=EOF){ + if(fabs(x0)+fabs(y0)+fabs(v)+fabs(angle)+fabs(t)+fabs(g)+ + fabs(r)<0.0000001)break; + scanf("%d", &n); + for(i=0; i +#include +#include +using namespace std; +const int N=100005; +struct node +{ + int y,next; +}; +bool vis[N]; +node path[N]; +int first[N],t; +double dp[N]; +void add(int x,int y) +{ + path[t].y=y; + path[t].next=first[x]; + first[x]=t++; +} +int main() +{ + double s; + int n,m,v; + while(cin>>n>>m) + { + if(m==0&&n==0) break; + memset(dp,0,sizeof(dp)); + memset(vis,0,sizeof(vis)); + memset(first,0,sizeof(first)); + int x,y; + t=1; + while(m--) + { + cin>>x>>y; + add(y,x); + } + dp[n]=-1; + for(int i=n; i>=0; i--) + { + if(!vis[i]) + { + vis[i]=true; + s=0; + for(int k=1; k<=6; k++) + s+=dp[i+k]; + s/=6; + dp[i]+=(s+1); + } + for(int k=first[i]; k; k=path[k].next) + { + v=path[k].y; + dp[v]=dp[i]; + vis[v]=true; + } + } + printf("%.4lf\n",dp[0]); + } + return 0; +} diff --git a/HDOJ/4406_autoAC.cpp b/HDOJ/4406_autoAC.cpp new file mode 100644 index 0000000..cac2168 --- /dev/null +++ b/HDOJ/4406_autoAC.cpp @@ -0,0 +1,142 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#define LL long long +#define myabs(x) ((x)>0?(x):(-(x))) +using namespace std; +const int inf=0x3f3f3f3f; +const double tinf=100000; +const int maxn=100; +const int maxm=1500*2; +struct Edge +{ + int from,to,next; + double val,cap,flow; +}; +Edge e[maxm]; +int head[maxn]; +int cre[maxn],bas[maxn],vis[maxn]; +double dis[maxn],score[110]; +int p[maxn]; +int n,kin,m,tot,s,t; +void addedge(int from,int to,double cap,double val) +{ + e[tot].from=from; e[tot].to=to; + e[tot].cap=cap; e[tot].flow=0; + e[tot].val=val; + e[tot].next=head[from]; + head[from]=tot++; + e[tot].from=to; e[tot].to=from; + e[tot].cap=0; e[tot].flow=0; + e[tot].next=head[to]; + e[tot].val=-val; + head[to]=tot++; +} +double mfmc() +{ + queue q; + int f; + double sum=0; + int i; + for(;;) + { + for(i=s;i<=t;i++) dis[i]=-inf; + memset(vis,0,sizeof(vis)); + dis[s]=0; + vis[s]=1; + q.push(s); + int i,v; + while(!q.empty()) + { + f=q.front(); q.pop(); + vis[f]=0; + for(i=head[f];i!=-1;i=e[i].next) + { + v=e[i].to; + if(e[i].cap>e[i].flow&&dis[f]+e[i].val>dis[v]) + { + p[v]=i; + dis[v]=dis[f]+e[i].val; + if(!vis[v]) + { + vis[v]=1; + q.push(v); + } + } + } + } + if(dis[t]<=0) break; + double a=(double)inf; + for(i=t;i!=s;) + { + a=min(a,e[p[i]].cap-e[p[i]].flow); + i=e[p[i]].from; + } + sum+=a*dis[t]; + for(i=t;i!=s;) + { + e[p[i]].flow+=a; + e[p[i]^1].flow-=a; + i=e[p[i]].from; + } + } + return sum; +} +int main() +{ + int i; + for(i=60;i<=100;i++) score[i]=4.0-3.0*(100-i)*(100-i)/1600; + while(~scanf("%d%d%d",&n,&kin,&m)) + { + if(!n&&!kin&&!m) break; + memset(head,-1,sizeof(head)); + int j,k,tem; + s=0; t=n+m+1; + tot=0; + double w=0,basic=0,sum=0; + for(i=1;i<=m;i++) + { + scanf("%d",&cre[i]); + w+=cre[i]; + } + for(i=1;i<=m;i++) + { + scanf("%d",&bas[i]); + if(bas[i]<60) + { + addedge(0,i,60-bas[i],tinf); + sum=sum+(60-bas[i])*tinf; + bas[i]=60; + } + basic=basic+score[bas[i]]*cre[i]; + for(j=bas[i]+1;j<=100;j++) + addedge(0,i,1,(score[j]-score[j-1])*cre[i]); + } + for(i=1;i<=n;i++) + { + for(j=1;j<=m;j++) + { + scanf("%d",&tem); + if(tem) + addedge(j,m+i,inf,0); + } + } + for(i=m+1;i=sum) + { + ans=(basic+(ans-sum))/w; + printf("%.6lf\n",ans); + } + else printf("0.000000\n"); + } + return 0; +} diff --git a/HDOJ/4407_autoAC.cpp b/HDOJ/4407_autoAC.cpp new file mode 100644 index 0000000..6d8f931 --- /dev/null +++ b/HDOJ/4407_autoAC.cpp @@ -0,0 +1,98 @@ +#include +#include +typedef __int64 LL; +using namespace std; +#define N 650 +bool np[N]; +int prime[120],fac[9],F_top,p; +LL ans; +void get_prime() +{ + int top = -1; + for(int i=2;i x || n-i < m-cnt) + return ; + dfs(i+1,cnt+1,m,n,num*fac[i],x); + dfs(i+1,cnt,m,n,num,x); +} +LL sovle(int n) +{ + ans = PreSum(n); + for(int m=1;m<=F_top;m++) + dfs(0,0,m,F_top,1,n); + return ans; +} +int gcd(int a,int b) +{ + return b ? gcd(b,a%b) : a; +} +int main() +{ + int z,n,Q,cmd,a,b; + get_prime(); + scanf("%d",&z); + map M; + while(z--) + { + M.clear(); + scanf("%d%d",&n,&Q); + while(Q--) + { + scanf("%d",&cmd); + if(cmd == 1) + { + scanf("%d%d%d",&a,&b,&p); + Div(p); + ans = sovle(b) - sovle(a-1); + for(map::iterator it=M.begin();it!=M.end();it++) + if((*it).first >= a && (*it).first <= b) + { + if(gcd((*it).first,p) == 1) + ans -= (*it).first; + if(gcd((*it).second,p) == 1) + ans += (*it).second; + } + printf("%I64d\n",ans); + } + else + { + scanf("%d%d",&a,&b); + M[a] = b; + } + } + } + return 0; +} diff --git a/HDOJ/4408_autoAC.cpp b/HDOJ/4408_autoAC.cpp new file mode 100644 index 0000000..1496525 --- /dev/null +++ b/HDOJ/4408_autoAC.cpp @@ -0,0 +1,125 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#define N 405 +#define M 4005 +#define E +#define inf 0x3f3f3f3f +#define dinf 1e10 +#define linf (LL)1<<60 +#define LL long long +#define clr(a,b) memset(a,b,sizeof(a)) +using namespace std; +LL mod; +struct Edge +{ + int a,b,c; + bool operator<(const Edge & t)const + { + return cgra[N]; +int findfa(int a,int b[]){return a==b[a]?a:b[a]=findfa(b[a],b);} +LL det(LL a[][N],int n) +{ + for(int i=0;i1) + { + for(int a=1;a<=n;a++) + for(int b=1;b<=n;b++) + tmp[a][b]=0; + int len=gra[i].size(); + for(int a=0;a +#include +#include +#include +#include +#include +#include +using namespace std; +#define M 30005 +map hasht; +map hashx; +struct cmp +{ + bool operator()(const int &a, const int &b) + { + return hasht.find(a)->secondsecond; + } +}; +struct point +{ + int pre; + set son; + string name; +}node[M]; +struct px +{ + int idx,len; +} temp; +int cnt; +stack father; +void dfs(int idx,int len) +{ + for(int i=0; i::iterator it=node[idx].son.begin(); it!=node[idx].son.end(); ++it) + dfs(*it,len+1); +} +void out_all() +{ + dfs(0,0); +} +void out_child() +{ + char s[70]; + scanf("%s",s); + if(hashx.count(string(s))==0) + { + printf("0\n"); + return; + } + if(string(s)==node[0].name) + { + printf("1\n"); + return; + } + int idx=hashx.find(string(s))->second; + printf("%d\n",node[node[idx].pre].son.size()); +} +void out_pre() +{ + char a[70],b[70]; + scanf("%s%s",a,b); + set ax; + int ida=hashx.find(string(a))->second; + int idb=hashx.find(string(b))->second; + for(; ida!=-1;) + { + ida=node[ida].pre; + ax.insert(ida); + } + for(; idb!=-1;) + { + idb=node[idb].pre; + if(ax.count(idb)!=0) break; + } + printf("%s\n",node[idb].name.c_str()); +} +int main() +{ + int n,m,pre; + char s[70],c,ord[10]; + string sx; + for(; scanf("%d",&n),n;) + { + for(int i=0; i<=n; ++i) + { + node[i].pre=-1; + node[i].son.clear(); + } + hashx.clear(); + hasht.clear(); + for(; !father.empty(); father.pop()); + cnt=0; + temp.idx=0; + temp.len=0; + scanf("%s",s); + sx=string(s); + node[cnt++].name=sx; + hashx.insert(make_pair(sx,0)); + hasht.insert(make_pair(0,sx)); + father.push(temp); + for(int i=1; i=temp.len) + father.pop(); + else + break; + } + sx=string(s); + int tx=father.top().idx; + node[cnt].pre=tx; + node[cnt].name=sx; + hasht.insert(make_pair(cnt,sx)); + hashx.insert(make_pair(sx,cnt)); + node[tx].son.insert(cnt); + cnt++; + father.push(temp); + } + scanf("%d",&m); + for(; m--;) + { + scanf("%s",ord); + if(ord[0]=='L') + out_all(); + else if(ord[0]=='b') + out_child(); + else if(ord[0]=='c') + out_pre(); + } + } + return 0; +} diff --git a/HDOJ/4410_autoAC.cpp b/HDOJ/4410_autoAC.cpp new file mode 100644 index 0000000..c1544fa --- /dev/null +++ b/HDOJ/4410_autoAC.cpp @@ -0,0 +1,168 @@ +#include +#include +#include +#include +#include +#include +#include +using namespace std; +const double INF = 1e19; +double EPS = 1e-12; +bool zero(double t){return -EPS0) t++; + } + if(t==1){ + for(int i=0;i<6;i++) + if(re[i]>0) k=i; + }else{ + for(int i=0;i<6;i++) + if(re[i]<0) k=i; + } + return min(dist(p[k],p[(k+3)%n]),min(fabs(p[(k+2)%n].x-p[(k+n-2)%n].x),fabs(p[(k+2)%n].y-p[(k+n-2)%n].y))); +} +double oor6(int a,int b) +{ + cpoint t1 = p[(a+n-2)%n],t2 = p[(b+3)%n]; + return min(fabs(t1.x-t2.x),min(fabs(t1.y-t2.y),max(dist(p[a],p[(a+n-3)%n]),dist(p[b],p[(b+3)%n])))); +} +double oor5(int a,int b) +{ + cpoint t1 = p[(a+n-2)%n],t2 = p[(b+2)%n]; + return min(fabs(t1.x-t2.x),min(fabs(t1.y-t2.y),min(dist(p[a],p[(a+n-3)%n]),dist(p[b],p[(b+3)%n])))); +} +double oor4(int a,int b) +{ + double ans; + if(zero(p[(a-2+n)%n].y-p[(b+2)%n].y)) + { + ans = min(fabs(p[(a-1+n)%n].x-p[(b+1)%n].x),fabs(p[(a-2+n)%n].y-p[(a+2)%n].y)); + }else{ + ans = min(fabs(p[(a-1+n)%n].y-p[(b+1)%n].y),fabs(p[(a-2+n)%n].x-p[(a+2)%n].x)); + } + ans = min(ans,min(dist(p[a],p[(a-3+n)%n]),dist(p[b],p[(b+3)%n]))); + return ans; +} +double oor3(int a,int b) +{ + cpoint t1 = p[(a+2)%n],t2 = p[(b+2)%n]; + double ans = min(fabs(t1.x-t2.x),fabs(t1.y-t2.y)); + double A1=INF,A2=INF,B1=INF,B2=INF; + if(intersect(segline(p[a],p[(a+3)%n]),segline(p[(a+4)%n],p[(a+5)%n]))) + A1=min(dist(p[(a+1)%n],p[(a+2)%n]),dist(p[b],p[(a+1)%n])); + if(intersect(segline(p[a],p[(a-3+n)%n]),segline(p[(a-4+n)%n],p[(a-5+n)%n]))) + A2=min(dist(p[(a-1+n)%n],p[(a-2+n)%n]),dist(p[b],p[(a-1+n)%n])); + if(intersect(segline(p[b],p[(b+3)%n]),segline(p[(b+4)%n],p[(b+5)%n]))) + B1=min(dist(p[(b+1)%n],p[(b+2)%n]),dist(p[a],p[(b+1)%n])); + if(intersect(segline(p[b],p[(b-3+n)%n]),segline(p[(b-4+n)%n],p[(b-5+n)%n]))) + B2=min(dist(p[(b-1+n)%n],p[(b-2+n)%n]),dist(p[a],p[(b-1+n)%n])); + if(A1!=INF) + ans = min(ans,max(B1,A1)); + if(A2!=INF) + ans = min(ans,max(B2,A2)); + // if(B1!=INF) + // ans = min(ans,max(dist(p[b],p[(b+5)%n]),B1)); + // if(B2!=INF) + // ans = min(ans,max(dist(p[b],p[(b+3)%n]),B2)); + //double A = max(min(dist(p[a],p[(a+3)%n]),A1),min(dist(p[a],p[(a+5)%n]),A2)); + // double B = max(min(dist(p[b],p[(b+3)%n]),B1),min(dist(p[b],p[(b+5)%n]),B2)); + ans = min(ans,max(min(dist(p[a],p[(a-3+n)%n]),dist(p[b],p[(b+3)%n])), + min(dist(p[a],p[(a+3)%n]),dist(p[b],p[(b-3+n)%n])))); + return ans; +} +double solve8() +{ + double re[10]; + int t=0; + for(int i=0;i0) t++; + } + if(t==2){ + }else{ + for(int i=0;i0){ + s=max(s,k); + k=0; + if(i4) swap(a,b); + if(s==6) + return oor6(a,b); + if(s==5) + return oor5(a,b); + if(s==4) + return oor4(a,b); + if(s==3) + return oor3(a,b); + return 0; +} +int main() +{ + while(scanf("%d",&n)&&n) + { + for(int i=0;i +#include +#define clr(x)memset(x,0,sizeof(x)) +#define INF 0x1f1f1f1f +#define min(a,b)(a)<(b)?(a):(b) +#define max(a,b)(a)>(b)?(a):(b) +struct node +{ + int next,from,to,w,c; +}e[1000010]; +int tot; +int head[210]; +void add(int st,int u,int wi,int flow) +{ + e[tot].from=st; + e[tot].to=u; + e[tot].w=wi; + e[tot].c=flow; + e[tot].next=head[st]; + head[st]=tot++; + e[tot].from=u; + e[tot].to=st; + e[tot].w=-wi; + e[tot].c=0; + e[tot].next=head[u]; + head[u]=tot++; +} +int q[100010]; +int pre[2010]; +int dis[2010]; +int v[220]; +int s,t; +int spfa() +{ + int i,x,front,rear,k; + front=rear=0; + for(i=0;i<=t;i++) + dis[i]=INF; + clr(v); + pre[s]=-1; + q[rear++]=s; + dis[s]=0; + v[s]=1; + while(front0) + q[--front]=k; + else q[rear++]=k; + } + } + } + } + if(dis[t]!=INF) + return 1; + return 0; +} +int costflow() +{ + int tt=0; + int tot=0,flow=0,u,minf=INF; + while(spfa()) + { + for(u=pre[t];u!=-1;u=pre[e[u].from]) + minf=min(minf,e[u].c); + for(u=pre[t];u!=-1;u=pre[e[u].from]) + { + e[u].c-=minf; + e[u^1].c+=minf; + flow+=e[u].w*minf; + } + } + return flow; +} +int g[105][105]; +int main() +{ + int m,n,a,b,c,k,K,w,z,i,j; + while(scanf("%d%d%d",&n,&m,&K)!=EOF) + { + if(n==0&&m==0&&K==0) + break; + memset(g,INF,sizeof(g)); + for(i=0;i<=n;i++) + g[i][i]=0; + while(m--) + { + scanf("%d%d%d",&a,&b,&w); + if(w +#include +#include +#include +#include +#include +#define MAXN 1005 +using namespace std; +double dp[55][MAXN], cost[MAXN][MAXN]; +map has; +struct Info{ +double pos; +double p; +}info[MAXN]; +int main() +{ + int N, M, i, n, a, j, k, pos; + double l, r, suml, sumr; + double b, min, temp, t; + while(scanf("%d%d",&N, &M)&&(N + M)) + { + has.clear(); + for( i = 1; i <= N; ++ i ) + { + scanf("%d", &n);++n; + while(--n) + { + scanf("%d%lf", &a, &b); + has[a]+=b; + } + } + N = 0; + for(map::iterator it = has.begin(); it != has.end(); ++it) + { + info[++N].pos = it->first; + info[N].p = it->second; + } + for(j = N; j >= 1; j--) + { + pos = j; + cost[j][j] = 0; + l = r = suml = 0; + sumr = info[j].p; + for(k = j-1; k >= 1; --k ) + { + suml += info[k].p; + l += (info[pos].pos-info[k].pos) * info[k].p; + temp = l + r; + while((pos > 1)&&(temp>(t = (l + r + (sumr - suml) * (info[pos].pos - info[pos - 1].pos))))) + { + l -= suml * (info[pos].pos - info[pos - 1].pos); + r += sumr * (info[pos].pos - info[pos - 1].pos); + --pos; + suml -= info[pos].p; + sumr +=info[pos].p; + temp = t; + } + cost[k][j] = temp; + } + } + for(i = 1; i <= N; i++)dp[0][i] = 1e300; + for(i = 0; i <= M; i++)dp[i][0] = 0; + for(i = 1; i <= M; i++) + { + for(j = N; j >= 1; j--) + { + min = dp[i-1][j-1] + cost[j][j]; + for(k = j-1; k >= 1; --k ) + { + if(dp[i - 1][k - 1] + cost[k][j] < min)min = dp[i - 1][k - 1] + cost[k][j]; + } + dp[i][j] = min; + } + } + printf("%0.2lf\n",dp[M][N]); + } + return 0; +} diff --git a/HDOJ/4413_autoAC.cpp b/HDOJ/4413_autoAC.cpp new file mode 100644 index 0000000..643efe5 --- /dev/null +++ b/HDOJ/4413_autoAC.cpp @@ -0,0 +1,136 @@ +#include +#include +#include +#include +#include +#include +using namespace std; +typedef pair node; +vector ans; +bool vis[50]; +int V[50]; +bool cmp(string s1,string s2){ + return s1+s2 tmpAns; + for (i=0;i<(1< tmp; + for (i=0;i<(1<minsize) continue; + string tans2=StInS(i,n,s); + if (tans2.empty()) continue; + if (ctrl= best) return; + if (cover==all) { + memcpy(ause, use, sizeof(use)); + best = len; + return; + } + if (i==M) return; + use[i] = 1; + dfs(i+1, len+ans[i].first.length()+1, cover|ans[i].second); + use[i] = 0; + dfs(i+1, len, cover); +} +int main(){ + int i,s,j,v; + int cas=0; + for (;;){ + scanf("%d",&N); + if (N==0) break; + for (i=0;i<(1< astr; + for (i = 0; i < M; ++i) + if (ause[i]) astr.push_back(ans[i].first); + sort(astr.begin(), astr.end(), cmp2); + string fin = astr[0]; + for (i = 1; i < astr.size(); ++i) + fin += "+"+astr[i]; + cout << fin << '\n'; + } + return 0; +} diff --git a/HDOJ/4414_autoAC.cpp b/HDOJ/4414_autoAC.cpp new file mode 100644 index 0000000..989dbd2 --- /dev/null +++ b/HDOJ/4414_autoAC.cpp @@ -0,0 +1,90 @@ +#include +#include +char grid[70][70]; +int vis[70][70],midx[70],midy[70],top; +int dx[4]={-1,1,0,0}; +int dy[4]={0,0,-1,1}; +int N,acquire; +typedef struct node +{ + int x,y; +}Node; +Node queue[30000]; +int BFS(int x,int y) +{ + int rear,front; + int nx,ny,ox,oy; + int i,j,k,cnt,step=4; + cnt=rear=front=0; + queue[rear].x=x; + queue[rear++].y=y; + vis[x][y]=1; + while(front=0&&nx=0&&ny=0&&nx=0&&ny +#include +#include +#include +using namespace std; +struct px +{ + int a,b; +} node; +vector a,b; +bool cmp(const struct px &x,const struct px &y) +{ + return x.a=b[i].a) + { + ansn++; + mn+=b[i].a; + } + } + if(a.size()>0&&a[0].a<=m) + { + node=a[0]; + mm+=node.a; + for(int i=0; i0&&a[0].a<=m-mn) + { + node=a[0]; + mn+=node.a; + for(int i=0; i=0; --idb,--bx,++ans); + if(idb<0) + { + if(ans>ansn) printf("Case %d: %d %d\n",cas,ans,mm); + else if(ansmm?mm:mn); + } + else + { + int i,j; + for(i=1,j=0; i=a[i].a+mm) + { + mm+=a[i].a; + i++; + ans++; + idb--; + } + else break; + } + else + { + if(m>=b[j].a+mm) + { + mm+=b[j].a; + ans++; + j++; + } + else break; + } + } + for(;j<=idb;++j) + { + if(m>=b[j].a+mm) + { + mm+=b[j].a; + ans++; + j++; + } + else break; + } + if(ans>ansn) printf("Case %d: %d %d\n",cas,ans,mm); + else if(ansmm?mm:mn); + } + } + return 0; +} diff --git a/HDOJ/4416_autoAC.cpp b/HDOJ/4416_autoAC.cpp new file mode 100644 index 0000000..1d40558 --- /dev/null +++ b/HDOJ/4416_autoAC.cpp @@ -0,0 +1,100 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#define inf 1<<28 +#define M 6000005 +#define N 1000005 +#define maxn 300005 +#define Min(a,b) ((a)<(b)?(a):(b)) +#define Max(a,b) ((a)>(b)?(a):(b)) +#define pb(a) push_back(a) +#define mem(a,b) memset(a,b,sizeof(a)) +#define LL long long +#define MOD 1000000007 +using namespace std; +int wa[maxn],wb[maxn],wv[maxn],Ws[maxn]; +int cmp(int *r,int a,int b,int l) +{return r[a]==r[b]&&r[a+l]==r[b+l];} +void da(const int *r,int *sa,int n,int m){ + int i,j,p,*x=wa,*y=wb,*t; + for(i=0;i=0;i--) sa[--Ws[x[i]]]=i; + for(j=1,p=1;p=j) y[p++]=sa[i]-j; + for(i=0;i=0;i--) sa[--Ws[wv[i]]]=y[i]; + for(t=x,x=y,y=t,p=1,x[sa[0]]=0,i=1;i=1;i--){ + if(sa[i-1] +#include +#include +#include +using namespace std; +const int N = 100010; +struct dit{ + int num,id; +}dd[N]; +struct ask{ + int lp,rp,value,id; +}aa[N]; +int cnt[N]; +bool cmp1(dit a,dit b){ + return a.num < b.num; +} +bool cmp2(ask a,ask b){ + return a.value < b.value; +} +int inline lowbit(int x){ + return x & (-x); +} +void inline update(int x){ + while(x < N){ + cnt[x]++; + x += lowbit(x); + } +} +int inline sum(int x){ + int s = 0; + while(x > 0){ + s += cnt[x]; + x -= lowbit(x); + } + return s; +} +int main(){ + int numcase; + scanf("%d",&numcase); + for(int ca = 1; ca <= numcase; ++ca){ + int n,m; + memset(cnt,0,sizeof(cnt)); + scanf("%d%d",&n,&m); + for(int i = 0; i < n; ++i){ + scanf("%d",&dd[i].num); + dd[i].id = i + 1; + } + int x,y; + for(int i = 0; i < m; ++i){ + scanf("%d%d%d",&x,&y,&aa[i].value); + aa[i].lp = x + 1; + aa[i].rp = y + 1; + aa[i].id = i + 1; + } + sort(dd,dd+n,cmp1); + sort(aa,aa+m,cmp2); + int ans[N] = {0}; + for(int aski = 0,ditj = 0; aski < m; ++aski){ + while(ditj < n && aa[aski].value >= dd[ditj].num){ + update(dd[ditj].id); + ditj++; + } + ans[aa[aski].id] = sum(aa[aski].rp) - sum(aa[aski].lp - 1); + } + printf("Case %d:\n",ca); + for(int i = 1; i <= m; ++i){ + printf("%d\n",ans[i]); + } + } + return 0; +} diff --git a/HDOJ/4418_autoAC.cpp b/HDOJ/4418_autoAC.cpp new file mode 100644 index 0000000..be5f1fa --- /dev/null +++ b/HDOJ/4418_autoAC.cpp @@ -0,0 +1,109 @@ +#include +#include +#include +#include +#include +#include +#include +using namespace std; +#define M 205 +#define eps 1e-8 +int equ, var; +double a[M][M], x[M]; +int Gauss () +{ + int i, j, k, col, max_r; + for (k = 0, col = 0; k < equ && col < var; k++, col++) + { + max_r = k; + for (i = k+1; i < equ; i++) + if (fabs (a[i][col]) > fabs (a[max_r][col])) + max_r = i; + if (k != max_r) + { + for (j = col; j < var; j++) + swap (a[k][j], a[max_r][j]); + swap (x[k], x[max_r]); + } + x[k] /= a[k][col]; + for (j = col+1; j < var; j++) a[k][j] /= a[k][col]; + a[k][col] = 1; + for (i = 0; i < equ; i++) if (i != k) + { + x[i] -= x[k] * a[i][k]; + for (j = col+1; j < var; j++) a[i][j] -= a[k][j] * a[i][col]; + a[i][col] = 0; + } + } + return 1; +} +int has[M], vis[M], k, e, n, m; +double p[M], sum; +int bfs (int u) +{ + memset (has, -1, sizeof(has)); + memset (a, 0, sizeof(a)); + memset (vis, 0, sizeof(vis)); + int v, i, flg = 0; + queue q; + q.push (u); + k = 0; + has[u] = k++; + while (!q.empty ()) + { + u = q.front (); + q.pop (); + if (vis[u]) continue; + vis[u] = 1; + if (u == e || u == n-e) + { + a[has[u]][has[u]] = 1; + x[has[u]] = 0; + flg = 1; + continue; + } + a[has[u]][has[u]] = 1; + x[has[u]] = sum; + for (i = 1; i <= m; i++) + { + if (fabs (p[i]) < eps) continue; + v = (u + i) % n; + if (has[v] == -1) has[v] = k++; + a[has[u]][has[v]] -= p[i]; + q.push (v); + } + } + return flg; +} +int main() +{ + int t, s, d, i; + scanf ("%d", &t); + while (t--) + { + scanf ("%d%d%d%d%d", &n, &m, &e, &s, &d); + n = 2*(n-1); + sum = 0; + for (i = 1; i <= m; i++) + { + scanf ("%lf", p+i); + p[i] = p[i] / 100; + sum += p[i] * i; + } + if (s == e) + { + puts ("0.00"); + continue; + } + if (d > 0) s = (n - s) % n; + if (!bfs (s)) + { + puts ("Impossible !"); + continue; + } + equ = var = k; + Gauss (); + printf ("%.2f\n", x[has[s]]); + } + return 0; +} diff --git a/HDOJ/4419_autoAC.cpp b/HDOJ/4419_autoAC.cpp new file mode 100644 index 0000000..1fa41b0 --- /dev/null +++ b/HDOJ/4419_autoAC.cpp @@ -0,0 +1,119 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#define inf 1<<28 +#define M 6000005 +#define N 11005 +#define maxn 300005 +#define Min(a,b) ((a)<(b)?(a):(b)) +#define Max(a,b) ((a)>(b)?(a):(b)) +#define pb(a) push_back(a) +#define mem(a,b) memset(a,b,sizeof(a)) +#define LL long long +#define MOD 1000000007 +#define lson step<<1 +#define rson step<<1|1 +using namespace std; +struct segment{ + int x1,x2,y,val; + segment(){} + segment(int _x1,int _x2,int _y,int _v):x1(_x1),x2(_x2),y(_y),val(_v){} + bool operator<(const segment s)const{ + return y>1; + Bulid(lson,l,m); + Bulid(rson,m+1,r); +} +void Push_Up(int step){ + int state=(L[step].cnt[1]>0?1:0)|(L[step].cnt[2]>0?2:0)|(L[step].cnt[4]>0?4:0); + if(state){ + mem(L[step].len,0); + L[step].len[state]=x[L[step].right+1]-x[L[step].left]; + for(int i=1;i<8;i++){ + if(state!=(state|i)){ + int tmp=L[lson].len[i]+L[rson].len[i]; + L[step].len[state|i]+=tmp; + L[step].len[state]-=tmp; + } + } + } + else if(L[step].left!=L[step].right) + for(int i=1;i<8;i++) L[step].len[i]=L[lson].len[i]+L[rson].len[i]; + else mem(L[step].len,0); +} +void Update(int step,int l,int r,int val){ + if(L[step].left==l&&r==L[step].right) + val>0?++L[step].cnt[val]:--L[step].cnt[-val]; + else{ + int m=(L[step].left+L[step].right)>>1; + if(r<=m) Update(lson,l,r,val); + else if(l>m) Update(rson,l,r,val); + else{ + Update(lson,l,m,val); + Update(rson,m+1,r,val); + } + } + Push_Up(step); +} +int Bin(int m){ + int low=1,high=cnt,mid; + while(low<=high){ + mid=(low+high)>>1; + if(x[mid]==m) return mid; + if(x[mid] +#include +#include +using namespace std; +inline int min(int a,int b) { return a1024) temp-=1024; + ans=ans>temp?ans:temp; + } + printf("%d\n",ans); + continue; + } + } + else + { + flag=0; + ans=0; + for(i=0;i<5;i++) + for(l=0;l<5;l++) + for(j=0;j<5;j++) + { + if(i!=l && i!=j && l!=j) + { + temp=num[i]+num[l]+num[j]; + if(temp%1024==0) + { + temp=0; + for(k=0;k<5;k++) if(k!=i && k!=l && k!=j) temp+=num[k]; + while(temp>1024) temp-=1024; + ans=ans>temp?ans:temp; + flag=1; + } + } + } + if(flag) printf("%d\n",ans); + else printf("0\n"); + } + } + return 0; +} diff --git a/HDOJ/4424_autoAC.cpp b/HDOJ/4424_autoAC.cpp new file mode 100644 index 0000000..7978348 --- /dev/null +++ b/HDOJ/4424_autoAC.cpp @@ -0,0 +1,63 @@ +#include +#include +#include +#include +using namespace std; +#define MAXN 200200 +typedef long long LL; +int parent[MAXN]; +LL sum[MAXN]; +int cnt[MAXN]; +struct Edge{ + int u,v,w; +}edge[MAXN]; +int n; +void Initiate() +{ + memset(sum,0,(n+2)*sizeof(sum[0])); + for(int i=0;i<=n;i++){ + parent[i]=i; + cnt[i]=1; + } +} +int Find(int x) +{ + if(x==parent[x]) + return x; + parent[x]=Find(parent[x]); + return parent[x]; +} +void Union(int r1,int r2,LL w) +{ + parent[r1]=r2; + cnt[r2]+=cnt[r1]; + sum[r2]+=w; +} +int cmp(const Edge &p,const Edge &q) +{ + return p.w>q.w; +} +int main() +{ + while(~scanf("%d",&n)) + { + Initiate(); + for(int i=0;itmp2){ + Union(r2,r1,tmp1-sum[r1]); + }else + Union(r1,r2,tmp2-sum[r2]); + } + printf("%I64d\n",sum[Find(1)]); + } + return 0; +} diff --git a/HDOJ/4426_autoAC.cpp b/HDOJ/4426_autoAC.cpp new file mode 100644 index 0000000..36197c6 --- /dev/null +++ b/HDOJ/4426_autoAC.cpp @@ -0,0 +1,200 @@ +#include +#include +#include +#include +#include +#include +using namespace std; +const int maxn=4e5+9,maxm=11371111;; +const long long mod=777777777; +char a[maxn]; +int dp[maxn]; +unsigned long long sum[maxn],po[maxn]; +int n,m; +int score[maxn]; +int has[maxm],lon; +struct D +{ + int next,pos,size; + long long sum; + unsigned long long _key; + long long key; + bool operator <(const D & xx) const + { + return key0) + insert(i,dp[i]+1>>1,1); + priority_queue q; + while(!q.empty()) q.pop(); + for(int i=1;i<=lon;i++) + { + R now; + now.key=data[i].size; + now.t=i; + q.push(now); + } + while(!q.empty()) + { + int pos=data[q.top().t].pos; + int size=data[q.top().t].size; + long long ff=data[q.top().t].sum; + size--; + q.pop(); + if(size&&insert(pos,size,ff)) + { + R now; + now.t=lon; + now.key=size; + q.push(now); + } + } +} +long long nn[maxn],pp[maxn]; +void getkey(int t) +{ + data[t].key=nn[data[t].pos]; + int ff=data[t].pos+data[t].size*2; + if(ff>n) return ; + long long tmp=(nn[ff]*pp[data[t].size])%mod; + data[t].key=((data[t].key+mod-tmp))%mod; +} +void getnow() +{ + pp[0]=1; + for(int i=1;i<=n+1;i++) + { + pp[i]=(pp[i-1]*26)%mod; + } + nn[n+1]=0; + for(int i=n-1;i>=1;i-=2) + { + nn[i]=(nn[i+2]*26)%mod; + nn[i]=(nn[i]+score[(a[i]-'a'+1)])%mod; + } +} +void solve(long long num) +{ + getnow(); + for(int i=1;i<=lon;i++) + getkey(i); + sort(data+1,data+1+lon); + long long now=0; + for(int i=1;i<=lon;i++) + { + now+=data[i].sum; + if(now>=num) + { + printf("%I64d\n",data[i].key); + break; + } + } + if(now=1;i--) + { + a[i*2]=a[i]; + a[i*2-1]='#'; + } + n<<=1; + a[++n]='#'; + getpal(); + gethash(); + for(int i=1;i<=m;i++) + { + long long tmp; + scanf("%I64d",&tmp); + for(int j=1;j<=26;j++) + scanf("%d",&score[j]); + solve(tmp); + } + cout< +#include +#include +#include +using namespace std; +const int maxn=1010; +const int mod=1000000007; +int dp[2][maxn][maxn]; +int lcm[maxn][maxn]; +int fac[maxn]; +int gcd(int a,int b) +{ + int t; + while(b) + { + t=a%b; + a=b; + b=t; + } + return a; +} +int main() +{ + int n,m,k,cnt,i,j,p,q,e,f,t,v,mul,tt; + for(i=1; in) + break; + t=lcm[mul][fac[q]]; + dp[v^1][tt][t]+=dp[v][j][mul]; + dp[v^1][tt][t]%=mod; + } + } + } + v^=1; + } + printf("%d\n",dp[v][n][m]); + } + return 0; +} diff --git a/HDOJ/4429_autoAC.cpp b/HDOJ/4429_autoAC.cpp new file mode 100644 index 0000000..0b9fe9f --- /dev/null +++ b/HDOJ/4429_autoAC.cpp @@ -0,0 +1,170 @@ +#include +#include +#include +#include +#define maxn 2220 +using namespace std; +struct node{ + int xl,yl; + int xr,yr; + int num; + int deep; + int flag; + int l; + int r; + int fat; + void output() + { + printf("%d %d %d %d\n",xl,yl,xr,yr); + printf("l = %d r = %d %d\n",l,r,fat); + } + bool inside(int x,int y) + { + return (xl=1;i--) + if (seq[i].flag == 0 && seq[i].in(xl,yl) && seq[i].in(xr,yr)) + return i; + return 0; +} +void update(int xl,int yl,int xr,int yr) +{ + int root = get(xl,yl,xr,yr); + int xxl = seq[root].xl; + int yyl = seq[root].yl; + int xxr = seq[root].xr; + int yyr = seq[root].yr; + seq[root].flag = 1; + if (xl == xxl){ + build(xxl,yyl,xr,yr,++tot,root); + seq[root].l = tot; + build(xl,yl,xxr,yyr,++tot,root); + seq[root].r = tot; + }else{ + build(xxl,yyl,xr,yr,++tot,root); + seq[root].l = tot; + build(xl,yl,xxr,yyr,++tot,root); + seq[root].r = tot; + } + return ; +} +int find(int x,int y) +{ + for (int i=tot;i>=1;i--) + if (seq[i].flag==0 && seq[i].inside(x,y)) + return i; + return 0; +} +bool fff[maxn][maxn]; +void dfs(int root,int niuniu) +{ + fff[niuniu][root] = true; + if (seq[root].l > 0) + dfs(seq[root].l,niuniu); + if (seq[root].r > 0) + dfs(seq[root].r,niuniu); + return ; +} +void dfs1(int root,int deep) +{ + int l = seq[root].l; + int r = seq[root].r; + seq[root].deep = deep; + if (l > 0){ + dfs1(l,deep+1); + seq[root].num += seq[l].num; + } + if (r > 0){ + dfs1(r,deep+1); + seq[root].num += seq[r].num; + } + return ; +} +void init() +{ + total = 0; + for (int i=1;i<=tot;i++) + if (seq[i].flag==0){ + seq[i].num = 1; + total++; + } + memset(fff,0,sizeof(fff)); + dfs1(1,1); + for (int i=1;i<=tot;i++) + dfs(i,i); + return ; +} +int solve(int u,int v) +{ + for (int i=tot;i>=1;i--) + { + if (fff[i][u] && fff[i][v]){ + int res = total - seq[i].num + 1; + return res; + } + } + return 0; +} +int main() +{ + int xl,yl,xr,yr; + while (scanf("%d%d%d%d",&xl,&yl,&xr,&yr)==4) + { + tot = 0; + build(xl,yl,xr,yr,++tot,0); + scanf("%d%d",&n,&m); + for (int i=1;i<=n;i++) + { + scanf("%d%d%d%d",&xl,&yl,&xr,&yr); + if (xl == xr) + { + if (yl > yr) + { + swap(yl,yr); + } + } + if (yl==yr) + { + if (xl > xr) + { + swap(xl,xr); + } + } + update(xl,yl,xr,yr); + } + init(); + for (int i=1;i<=m;i++) + { + scanf("%d%d%d%d",&xl,&yl,&xr,&yr); + int p1 = find(xl,yl); + int p2 = find(xr,yr); + int ans = solve(p1,p2); + printf("%d\n",ans); + } + } + return 0; +} diff --git a/HDOJ/4430_autoAC.cpp b/HDOJ/4430_autoAC.cpp new file mode 100644 index 0000000..bcf46ad --- /dev/null +++ b/HDOJ/4430_autoAC.cpp @@ -0,0 +1,50 @@ +#include +#include +#include +#include +using namespace std; +#define ll __int64 +ll n; +ll bin(ll s) +{ + ll l = 2,r = n,mid,i; + while(l<=r) + { + mid = (l+r)/2; + ll sum = 1,ans = 0;; + for(i = 1; i<=s; i++) + { + if(n/sumn) + break; + } + if(ans == n || ans == n-1) return mid; + else if(ans +#include +#include +#include +#include +#include +#include +#include +#define LL long long +#define mem(a,b) memset(a,b,sizeof(a)) +using namespace std; +mapm; +void Init() +{ + m["1m"]=1;m["2m"]=2;m["3m"]=3; + m["4m"]=4;m["5m"]=5;m["6m"]=6; + m["7m"]=7;m["8m"]=8;m["9m"]=9; + m["1s"]=10;m["2s"]=11;m["3s"]=12; + m["4s"]=13;m["5s"]=14;m["6s"]=15; + m["7s"]=16;m["8s"]=17;m["9s"]=18; + m["1p"]=19;m["2p"]=20;m["3p"]=21; + m["4p"]=22;m["5p"]=23;m["6p"]=24; + m["7p"]=25;m["8p"]=26;m["9p"]=27; + m["1c"]=28;m["2c"]=29;m["3c"]=30; + m["4c"]=31;m["5c"]=32;m["6c"]=33; + m["7c"]=34; +} +int c[35];int b[14]; +int c13[13]={1,9,10,18,19,27,28,29,30,31,32,33,34}; +bool judge1() +{ + int c1=0,c2=0; + for(int i=0;i<13;i++) + { + if(c[c13[i]]) c1++; + if(c[c13[i]]>1) c2++; + } + if(c1==13&&c2==1) return true; + return false; +} +bool judge2() +{ + for(int i=0;i<14;i+=2) + { + if((i&&b[i]==b[i-1])||b[i]!=b[i+1]) return false; + } + return true; +} +bool flag; +bool check(int idx) +{ + if(idx>=1&&idx<=7) return true; + if(idx>=10&&idx<=16) return true; + if(idx>=19&&idx<=25) return true; + return false; +} +void dfs(int idx,int k1,int k2) +{ + if(flag) return; + if(k1>4||k2>1) return ; + if(idx==14) + { + if(k1==4&&k2==1){flag=true;} + return ; + } + for(int i=1;i<=34;i++) + { + int mark=0; + if(c[i]>=3) {c[i]-=3;mark++;dfs(idx+3,k1+1,k2);c[i]+=3;} + if(c[i]>=2) {c[i]-=2;mark++;dfs(idx+2,k1,k2+1);c[i]+=2;} + if(check(i)&&c[i]&&c[i+1]&&c[i+2]) {c[i]--;c[i+1]--;c[i+2]--;mark++;dfs(idx+3,k1+1,k2);c[i]++;c[i+1]++;c[i+2]++;} + if(c[i]&&mark==0) return ; + if(c[i]) break; + } +} +int a[14]; +int slove() +{ + memcpy(b,a,sizeof(a)); + sort(b,b+14); + mem(c,0); + for(int i=0;i<14;i++) + { + c[b[i]]++; + if(c[b[i]]>4)return false; + } + if(judge1()) return true; + if(judge2()) return true; + flag=false; + dfs(0,0,0); + return flag; +} +int main() +{ + m.clear(); + Init(); + int t; + cin>>t; + while(t--) + { + for(int i=0;i<13;i++) + { + string s; + cin>>s; + a[i]=m[s]; + } + int ans[50],cnt=0; + for(int i=1;i<=34;i++) + { + a[13]=i; + if(slove()) ans[cnt++]=i; + } + if(cnt==0) cout<<"Nooten"<::iterator it=m.begin();it!=m.end();it++) + { + if(it->second==ans[i]) + { + cout<<" "<<(it->first); + break; + } + } + } + cout< +#include +#include +#include +#include +using namespace std; +int bit[100]; +int cnt; +void change(int n,int base) +{ + cnt=0; + while(n) + { + bit[cnt++]=n%base; + n/=base; + } +} +int main() +{ + int n,m; + while(scanf("%d%d",&n,&m)!=EOF) + { + int sum=0; + int t=(int)sqrt(n*1.0); + for(int i=1;i<=t;i++) + { + if(n%i==0) + { + int tmp=i; + while(tmp) + { + sum+=((tmp%m)*(tmp%m)); + tmp/=m; + } + tmp=n/i; + if(tmp==i)continue; + while(tmp) + { + sum+=((tmp%m)*(tmp%m)); + tmp/=m; + } + } + } + change(sum,m); + for(int i=cnt-1;i>=0;i--) + { + if(bit[i]>9)printf("%c",bit[i]-10+'A'); + else printf("%d",bit[i]); + } + printf("\n"); + } + return 0; +} diff --git a/HDOJ/4433_autoAC.cpp b/HDOJ/4433_autoAC.cpp new file mode 100644 index 0000000..b9b299a --- /dev/null +++ b/HDOJ/4433_autoAC.cpp @@ -0,0 +1,58 @@ +#include +#include +#include +#include +#define MAXN 1000+100 +using namespace std; +int f[MAXN][12][12]; +int times[12][12]; +int n,m; +char s[MAXN],t[MAXN]; +int a[MAXN],b[MAXN]; +int min(int a,int b){return (a +#include +#include +#define clr(x)memset(x,0,sizeof(x)) +const double eps = 1e-8; +#define maxn 130 +struct pos +{ + double x, y; +}p[maxn]; +double d[maxn][maxn]; +double dis(pos a, pos b) +{ + return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y)); +} +double D; +int n; +int res[maxn]; +bool ok() +{ + int tot = 1; + int q[maxn]; + bool v[maxn]; + int front = 0, rear = 0; + int u, i; + memset(v,false,sizeof(v)); + v[0] = true; + q[rear++] = 0; + while(front < rear) + { + u = q[front++]; + for(i=0; i0; i--) + { + res[i] = 0; + if(!ok()){ + res[i] = 1; + if(i == n) + { f = 1; + break; + } + } + } + if(f == 1) + { + printf("-1\n"); + continue; + } + int flag = 0; + for(i=n-1; i>=0; i--) + if(flag || res[i] !=0) + { + printf("%d",res[i]); + flag = 1; + } + putchar('\n'); + } + return 0; +} diff --git a/HDOJ/4436_autoAC.cpp b/HDOJ/4436_autoAC.cpp new file mode 100644 index 0000000..4177457 --- /dev/null +++ b/HDOJ/4436_autoAC.cpp @@ -0,0 +1,95 @@ +#include +#include +#include +#include +#include +#include +#include +#define maxn 300000 +#define MOD 2012 +using namespace std; +int wa[maxn],wb[maxn],wv[maxn]; +int ran[maxn],height[maxn],wS[maxn],sa[maxn],P[maxn],Pow[maxn],V[maxn], +T[maxn],Len[maxn],S[maxn],arrive[maxn],n,len,value; +char s[maxn]; +int cmp(int *r,int a,int b,int l) {return r[a]==r[b]&&r[a+l]==r[b+l];} +void da(int *r,int *sa,int n,int m) +{ + int i,j,p,*x=wa,*y=wb,*t; + for(i=0;i=0;i--) sa[--wS[x[i]]]=i; + for(j=1,p=1;p=j) y[p++]=sa[i]-j; + for(i=0;i=0;i--) sa[--wS[wv[i]]]=y[i]; + for(t=x,x=y,y=t,p=1,x[sa[0]]=0,i=1;ir) return 0; + int ans=(T[r+1]-T[l])%MOD; + ans-=V[l]*(Pow[r-l+1]); + ans%=MOD; + if (ans<0) ans+=MOD; + return ans; +} +int main() +{ + Pow[0]=1;Pow[1]=10; + for (int i=2;i<200000;++i) + Pow[i]=(Pow[i-1]+1)*10%MOD; + while (scanf("%d",&n)!=EOF) + { + len = 0; value = 0; + for (int i=0;i < n ;++i){ + scanf("%s",s); + Len[i]= strlen(s); + for (int j = 0 ; j < Len[i]; ++j){ + S[len]=s[j]-'0'+1; + value = (value*10+S[len]-1)%MOD; + V[len+1]=value; + T[len+1]=(T[len]+value)%MOD; + P[len]=i; + len++; + } + S[len]=11; + value = (value*10+10)%MOD; + V[len+1]=value; + T[len+1]=(T[len]+value)%MOD; + P[len]=i; + len++; + arrive[i]=len-2; + } + S[len-1]=0; + da(S,sa,len,12); + calheight(S,sa,len); + int ans = 0; + for (int i = 0;i < len;++i) + if (S[i]%10 !=1){ + if (i+height[ran[i]]<= arrive[P[i]]){ + ans+=get(i,arrive[P[i]])-get(i,i+height[ran[i]]-1); + ans%=MOD;if (ans<0) ans+=MOD; + } + } + cout << ans << endl; + } + return 0; +} diff --git a/HDOJ/4438_autoAC.cpp b/HDOJ/4438_autoAC.cpp new file mode 100644 index 0000000..cc8f73c --- /dev/null +++ b/HDOJ/4438_autoAC.cpp @@ -0,0 +1,21 @@ +#include +#include +#include +#include +using namespace std; +int main() +{ + int X,Y; + double P,Q; + int T; + scanf("%d",&T); + while(T--) + { + scanf("%d%d%lf%lf",&X,&Y,&P,&Q); + double ans1=(1-Q)*X+Q*(P*X+P*Y); + double ans2=Q*Y+(1-Q)*(P*X+P*Y); + if(ans1>ans2)printf("tiger %.4lf\n",ans1); + else printf("wolf %.4lf\n",ans2); + } + return 0; +} diff --git a/HDOJ/4439_autoAC.cpp b/HDOJ/4439_autoAC.cpp new file mode 100644 index 0000000..124110f --- /dev/null +++ b/HDOJ/4439_autoAC.cpp @@ -0,0 +1,104 @@ +#include +#include +#include +#include +#include +using namespace std; +const int maxn = 1011; +const double eps = 1e-8; +const double pi = acos(-1.0); +inline double dcmp(double x) {return (x > eps) - (x < -eps);} +inline double Sqr(double x) {return x * x;} +struct Point +{ + double x, y, v; + Point(){} + Point(double x_, double y_){x = x_, y = y_;} + double Dis(Point &b){return sqrt(Sqr(x - b.x) + Sqr(y - b.y));} +}; +Point p[maxn], th; +int n; +void AngManage(double &x) +{ + while(x + pi < -eps) x += pi + pi; + while(x - pi > -eps) x -= pi + pi; +} +inline double CounterAng(double s, double e) +{return e > s + eps ? e - s : pi + pi + e - s;} +struct Cov +{ + double s, e; + void Read(double s_, double e_) + { + AngManage(s_), AngManage(e_); + s = s_, e = e_; + } + bool operator<(const Cov &b)const + { + if(!dcmp(s - b.s)) return CounterAng(s, e) > CounterAng(b.s, b.e); + return s < b.s; + } +} cover[maxn], cc[maxn]; +int main() +{ + int t, i, j, k, ans, cnt; + bool flag; + for(scanf("%d", &t); t --; ) + { + flag = false; + scanf("%d", &n); + scanf("%lf%lf%lf", &th.v, &th.x, &th.y); + for(i = 0; i < n; ++ i) + { + scanf("%lf%lf%lf", &p[i].v, &p[i].x, &p[i].y); + if(p[i].v > th.v + eps || !dcmp(p[i].Dis(th))) flag = true; + } + if(flag) {printf("1\n"); continue;} + if(!dcmp(th.v)) {printf("0\n"); continue;} + for(i = 0; i < n; ++ i) + { + double ang = atan2(p[i].y - th.y, p[i].x - th.x); + if(p[i].v > th.v - eps) + { + cover[i].Read(ang - pi * 0.5, ang + pi * 0.5); + continue; + } + double c = p[i].Dis(th); + double T = sqrt(Sqr(c) / (Sqr(th.v) - Sqr(p[i].v))); + double cs = acos(c / T / th.v); + cover[i].Read(ang - cs, ang + cs); + } + sort(cover, cover + n); + for(i = k = 1; i < n; ++ i) + if(dcmp(cover[i].s - cover[i - 1].s)) cover[k ++] = cover[i]; + n = k; + for(i = 0, ans = 0x3f3f3f3f; i < n; ++ i) + { + for(j = i, k = 0; ; j = (j + 1) % n) + { + cc[k].Read(cover[j].s - cover[i].s - pi, cover[j].e - cover[i].s - pi); + if(cc[k].s > cc[k].e) cc[k].e = pi + pi; + ++ k; + if(j == (i + n - 1) % n) break; + } + double now = -pi - pi, nex = -pi; + flag = false; + for(j = cnt = 0; j < n; ++ j) + { + if(cc[j].e < now + eps) continue; + if(cc[j].s > nex + eps) break; + if(cc[j].s > now + eps) + { + ++ cnt; + now = nex; + } + if(cc[j].e > nex + eps) nex = cc[j].e; + if(nex > pi - eps) {flag = true; break;} + } + if(flag) ans = min(ans, cnt); + } + if(ans == 0x3f3f3f3f) ans = 0; + printf("%d\n", ans); + } + return 0; +} diff --git a/HDOJ/4441_autoAC.cpp b/HDOJ/4441_autoAC.cpp new file mode 100644 index 0000000..b8f56ca --- /dev/null +++ b/HDOJ/4441_autoAC.cpp @@ -0,0 +1,405 @@ +#include +#include +#include +#define MAXD 200010 +typedef long long LL; +namespace SP +{ + int T, node; + struct Splay + { + int ls, rs, pre, size, num[2], key; + LL sum; + void update(); void zig(int x); void zag(int x); void splay(int x, int goal); + void init() + { + ls = rs = pre = 0; + key = size = sum = num[0] = num[1] = 0; + } + }sp[MAXD]; + void init() + { + T = 1, node = 2; + sp[0].init(), sp[1].init(), sp[2].init(); + sp[1].rs = 2, sp[2].pre = 1; + sp[1].size = 2, sp[2].size = 1; + } + inline void Splay::update() + { + size = sp[ls].size + sp[rs].size + 1; + sum = sp[ls].sum + sp[rs].sum + key; + num[0] = sp[ls].num[0] + sp[rs].num[0] + (key < 0); + num[1] = sp[ls].num[1] + sp[rs].num[1] + (key > 0); + } + inline void Splay::zig(int x) + { + int y = rs, fa = pre; + rs = sp[y].ls, sp[rs].pre = x; + sp[y].ls = x, pre = y; + sp[y].pre = fa; + if(fa == 0) T = y; + else sp[fa].ls == x ? sp[fa].ls = y : sp[fa].rs = y; + update(); + } + inline void Splay::zag(int x) + { + int y = ls, fa = pre; + ls = sp[y].rs, sp[ls].pre = x; + sp[y].rs = x, pre = y; + sp[y].pre = fa; + if(fa == 0) T = y; + else sp[fa].ls == x ? sp[fa].ls = y : sp[fa].rs = y; + update(); + } + void Splay::splay(int x, int goal) + { + int y, z; + for(; pre != goal;) + { + y = pre; + if(sp[y].pre == goal) sp[y].rs == x ? sp[y].zig(y) : sp[y].zag(y); + else + { + z = sp[y].pre; + if(sp[z].rs == y) + { + if(sp[y].rs == x) sp[z].zig(z), sp[y].zig(y); + else sp[y].zag(y), sp[z].zig(z); + } + else + { + if(sp[y].ls == x) sp[z].zag(z), sp[y].zag(y); + else sp[y].zig(y), sp[z].zag(z); + } + } + } + update(); + } + void newnode(int &cur) + { + cur = ++ node; + sp[cur].init(); + } + int insert(int &cur, int fa, int key) + { + newnode(cur); + sp[cur].key = key, sp[cur].pre = fa, sp[cur].update(); + return cur; + } + int find(int k) + { + if(sp[T].size < k) return -1; + int i = T; + for(;;) + { + int n = sp[sp[i].ls].size; + if(n + 1 == k) break; + if(k <= n) i = sp[i].ls; + else i = sp[i].rs, k -= n + 1; + } + return i; + } +} +int N, D, min[4 * MAXD], loc[MAXD][2]; +void update(int i) +{ + for(; i ^ 1; i >>= 1) min[i >> 1] = std::min(min[i], min[i ^ 1]); +} +void init() +{ + for(D = 1; D < N + 2; D <<= 1); + memset(min, 0, sizeof(min[0]) * D * 2); + min[D] = 1, update(D); + SP::init(); +} +int find() +{ + int i = 1; + for(; i < D;) + { + if(min[i << 1] == 0) i <<= 1; + else i = i << 1 | 1; + } + return i - D; +} +void insert(int p) +{ + int i = find(), x, y, t; + min[D + i] = 1, update(D + i); + x = SP::find(p + 1), SP::sp[x].splay(x, 0); + y = SP::find(p + 2), SP::sp[y].splay(y, x); + t = SP::insert(SP::sp[y].ls, y, i); + SP::sp[y].update(), SP::sp[x].update(); + loc[i][1] = t, SP::sp[t].splay(t, 0); + int n = SP::sp[SP::sp[t].ls].num[1] + 1; + if(n > SP::sp[t].num[0]) + { + int k = SP::sp[t].size; + x = SP::find(k - 1), SP::sp[x].splay(x, 0); + y = SP::find(k), SP::sp[y].splay(y, x); + t = SP::insert(SP::sp[y].ls, y, -i); + SP::sp[y].update(), SP::sp[x].update(); + loc[i][0] = t; + } + else + { + int j = SP::T, k = n; + for(;;) + { + int n = SP::sp[SP::sp[j].ls].num[0], d = SP::sp[j].key < 0; + if(d == 1 && n + d == k) break; + if(k <= n) j = SP::sp[j].ls; + else j = SP::sp[j].rs, k -= n + d; + } + SP::sp[j].splay(j, 0); + x = SP::find(SP::sp[SP::sp[j].ls].size); + SP::sp[x].splay(x, j); + t = SP::insert(SP::sp[x].rs, x, -i); + SP::sp[x].update(), SP::sp[j].update(); + loc[i][0] = t; + } +} +void remove(int i) +{ + min[D + i] = 0, update(D + i); + for(int j = 0; j < 2; j ++) + { + SP::sp[loc[i][j]].splay(loc[i][j], 0); + int x, y, n = SP::sp[SP::sp[SP::T].ls].size + 1; + x = SP::find(n - 1), SP::sp[x].splay(x, 0); + y = SP::find(n + 1), SP::sp[y].splay(y, x); + SP::sp[y].ls = 0; + SP::sp[y].update(), SP::sp[x].update(); + } +} +void query(int i) +{ + int x = loc[i][1], y = loc[i][0]; + SP::sp[x].splay(x, 0), SP::sp[y].splay(y, x); + printf("%I64d\n", SP::sp[SP::sp[y].ls].sum); +} +void solve() +{ + char op[10]; + for(int i = 0; i < N; i ++) + { + int k; + scanf("%s%d", op, &k); + if(op[0] == 'i') insert(k); + else if(op[0] == 'r') remove(k); + else query(k); + } +} +int main() +{ + int t = 0; + while(scanf("%d", &N) == 1) + { + init(); + printf("Case #%d:\n", ++ t); + solve(); + } + return 0; +}#include +#include +#include +#define MAXD 200010 +typedef long long LL; +namespace SP +{ + int T, node; + struct Splay + { + int ls, rs, pre, size, num[2], key; + LL sum; + void update(); void zig(int x); void zag(int x); void splay(int x, int goal); + void init() + { + ls = rs = pre = 0; + key = size = sum = num[0] = num[1] = 0; + } + }sp[MAXD]; + void init() + { + T = 1, node = 2; + sp[0].init(), sp[1].init(), sp[2].init(); + sp[1].rs = 2, sp[2].pre = 1; + sp[1].size = 2, sp[2].size = 1; + } + inline void Splay::update() + { + size = sp[ls].size + sp[rs].size + 1; + sum = sp[ls].sum + sp[rs].sum + key; + num[0] = sp[ls].num[0] + sp[rs].num[0] + (key < 0); + num[1] = sp[ls].num[1] + sp[rs].num[1] + (key > 0); + } + inline void Splay::zig(int x) + { + int y = rs, fa = pre; + rs = sp[y].ls, sp[rs].pre = x; + sp[y].ls = x, pre = y; + sp[y].pre = fa; + if(fa == 0) T = y; + else sp[fa].ls == x ? sp[fa].ls = y : sp[fa].rs = y; + update(); + } + inline void Splay::zag(int x) + { + int y = ls, fa = pre; + ls = sp[y].rs, sp[ls].pre = x; + sp[y].rs = x, pre = y; + sp[y].pre = fa; + if(fa == 0) T = y; + else sp[fa].ls == x ? sp[fa].ls = y : sp[fa].rs = y; + update(); + } + void Splay::splay(int x, int goal) + { + int y, z; + for(; pre != goal;) + { + y = pre; + if(sp[y].pre == goal) sp[y].rs == x ? sp[y].zig(y) : sp[y].zag(y); + else + { + z = sp[y].pre; + if(sp[z].rs == y) + { + if(sp[y].rs == x) sp[z].zig(z), sp[y].zig(y); + else sp[y].zag(y), sp[z].zig(z); + } + else + { + if(sp[y].ls == x) sp[z].zag(z), sp[y].zag(y); + else sp[y].zig(y), sp[z].zag(z); + } + } + } + update(); + } + void newnode(int &cur) + { + cur = ++ node; + sp[cur].init(); + } + int insert(int &cur, int fa, int key) + { + newnode(cur); + sp[cur].key = key, sp[cur].pre = fa, sp[cur].update(); + return cur; + } + int find(int k) + { + if(sp[T].size < k) return -1; + int i = T; + for(;;) + { + int n = sp[sp[i].ls].size; + if(n + 1 == k) break; + if(k <= n) i = sp[i].ls; + else i = sp[i].rs, k -= n + 1; + } + return i; + } +} +int N, D, min[4 * MAXD], loc[MAXD][2]; +void update(int i) +{ + for(; i ^ 1; i >>= 1) min[i >> 1] = std::min(min[i], min[i ^ 1]); +} +void init() +{ + for(D = 1; D < N + 2; D <<= 1); + memset(min, 0, sizeof(min[0]) * D * 2); + min[D] = 1, update(D); + SP::init(); +} +int find() +{ + int i = 1; + for(; i < D;) + { + if(min[i << 1] == 0) i <<= 1; + else i = i << 1 | 1; + } + return i - D; +} +void insert(int p) +{ + int i = find(), x, y, t; + min[D + i] = 1, update(D + i); + x = SP::find(p + 1), SP::sp[x].splay(x, 0); + y = SP::find(p + 2), SP::sp[y].splay(y, x); + t = SP::insert(SP::sp[y].ls, y, i); + SP::sp[y].update(), SP::sp[x].update(); + loc[i][1] = t, SP::sp[t].splay(t, 0); + int n = SP::sp[SP::sp[t].ls].num[1] + 1; + if(n > SP::sp[t].num[0]) + { + int k = SP::sp[t].size; + x = SP::find(k - 1), SP::sp[x].splay(x, 0); + y = SP::find(k), SP::sp[y].splay(y, x); + t = SP::insert(SP::sp[y].ls, y, -i); + SP::sp[y].update(), SP::sp[x].update(); + loc[i][0] = t; + } + else + { + int j = SP::T, k = n; + for(;;) + { + int n = SP::sp[SP::sp[j].ls].num[0], d = SP::sp[j].key < 0; + if(d == 1 && n + d == k) break; + if(k <= n) j = SP::sp[j].ls; + else j = SP::sp[j].rs, k -= n + d; + } + SP::sp[j].splay(j, 0); + x = SP::find(SP::sp[SP::sp[j].ls].size); + SP::sp[x].splay(x, j); + t = SP::insert(SP::sp[x].rs, x, -i); + SP::sp[x].update(), SP::sp[j].update(); + loc[i][0] = t; + } +} +void remove(int i) +{ + min[D + i] = 0, update(D + i); + for(int j = 0; j < 2; j ++) + { + SP::sp[loc[i][j]].splay(loc[i][j], 0); + int x, y, n = SP::sp[SP::sp[SP::T].ls].size + 1; + x = SP::find(n - 1), SP::sp[x].splay(x, 0); + y = SP::find(n + 1), SP::sp[y].splay(y, x); + SP::sp[y].ls = 0; + SP::sp[y].update(), SP::sp[x].update(); + } +} +void query(int i) +{ + int x = loc[i][1], y = loc[i][0]; + SP::sp[x].splay(x, 0), SP::sp[y].splay(y, x); + printf("%I64d\n", SP::sp[SP::sp[y].ls].sum); +} +void solve() +{ + char op[10]; + for(int i = 0; i < N; i ++) + { + int k; + scanf("%s%d", op, &k); + if(op[0] == 'i') insert(k); + else if(op[0] == 'r') remove(k); + else query(k); + } +} +int main() +{ + int t = 0; + while(scanf("%d", &N) == 1) + { + init(); + printf("Case #%d:\n", ++ t); + solve(); + } + return 0; +} diff --git a/HDOJ/4442_autoAC.cpp b/HDOJ/4442_autoAC.cpp new file mode 100644 index 0000000..560e50e --- /dev/null +++ b/HDOJ/4442_autoAC.cpp @@ -0,0 +1,35 @@ +#include"stdio.h" +#include"string.h" +#include"stdlib.h" +struct A +{ + __int64 a,b; +}E[100011]; +int cmp(const void *a,const void *b) +{ + struct A *c,*d; + c=(struct A *)a; + d=(struct A *)b; + __int64 t1,t2; + t1=(c->a)*(d->b); + t2=(d->a)*(c->b); + if(t1>t2) return 1; + else return -1; +} +int main() +{ + int n; + int i,l; + int temp; + __int64 ans; + while(scanf("%d",&n),n) + { + for(i=0;i +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +#ifdef _WIN32 +#define i64 __int64 +#define out64 "%I64d\n" +#define in64 "%I64d" +#else +#define i64 long long +#define out64 "%lld\n" +#define in64 "%lld" +#endif +#define FOR(i,a,b) for( int i = (a) ; i <= (b) ; i ++) +#define FF(i,a) for( int i = 0 ; i < (a) ; i ++) +#define FFD(i,a,b) for( int i = (a) ; i >= (b) ; i --) +#define S64(a) scanf(in64,&a) +#define SS(a) scanf("%d",&a) +#define LL(a) ((a)<<1) +#define RR(a) (((a)<<1)+1) +#define pb push_back +#define pf push_front +#define X first +#define Y second +#define CL(Q) while(!Q.empty())Q.pop() +#define MM(name,what) memset(name,what,sizeof(name)) +#define MC(a,b) memcpy(a,b,sizeof(b)) +#define MAX(a,b) ((a)>(b)?(a):(b)) +#define MIN(a,b) ((a)<(b)?(a):(b)) +#define read freopen("in.txt","r",stdin) +#define write freopen("out.txt","w",stdout) +const int inf = 0x3f3f3f3f; +const i64 inf64 = 0x3f3f3f3f3f3f3f3fLL; +const double oo = 10e9; +const double eps = 10e-9; +const double pi = acos(-1.0); +const int maxn = 100011; +vectorv[maxn]; +vectorg[maxn]; +vectors; +int n; +double nn; +int t[maxn]; +int f[maxn]; +int dfn[maxn]; +int low[maxn]; +int df,nf; +bool ins[maxn]; +int tot; +bool hash[maxn]; +int yes[33]; +double go[33][33]; +double back[33][33]; +double dpx[maxn]; +double dpy[maxn]; +bool vis[maxn]; +int cnt[maxn]; +double dp[maxn]; +double dps[maxn]; +vectorans; +void tarjan(int now) +{ + low[now] = dfn[now] = df++; + s.push_back(now); + ins[now]=true; + int to; + for(int i=0;i1) + { + tv=i; + break; + } + } + s.clear(); + tot = v[tv].size(); + for(int i=0;i<=n;i++) + { + ins[i]=false; + vis[i]=false; + } + for(int i=0;ieps) + { + ans.pb(dp[i]); + } + } + for(int i=1;i<=5;i++) + { + ans.pb(0.0); + } + sort(ans.begin(),ans.end()); + return ; +} +int main() +{ + while(cin>>n) + { + if(!n) return 0; + nn = n; + nn = 1.0/nn; + for(int i=0;i<=n;i++) + { + v[i].clear(); + g[i].clear(); + } + int now,to; + for(int i=1;i<=n;i++) + { + SS(now); + SS(to); + g[now].pb(to); + g[to].pb(now); + } + start(); + double re=0.0; + int ix = ans.size()-1; + for(int i=1;i<=5;i++) + { + re+=ans[ix--]; + } + printf("%.5lf\n",re); + } + return 0; +} diff --git a/HDOJ/4444_autoAC.cpp b/HDOJ/4444_autoAC.cpp new file mode 100644 index 0000000..c187fb5 --- /dev/null +++ b/HDOJ/4444_autoAC.cpp @@ -0,0 +1,161 @@ +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +const int INF = 0x3f3f3f3f; +const int N=109; +bool visit[N<<1][N<<1]; +map mpx; +map mpy; +int n; +struct cpoint{ + int x,y; + void get() + { + scanf("%d%d",&x,&y);x<<=1;y<<=1; + } +} st,en,re[59][2]; +int hashx[N<<1],hashy[N<<1],cnx,cny; +bool can[N][N][4][4]; +void init() +{ + mpx.clear();mpy.clear(); + memset(can,false,sizeof(can)); + cnx=0;cny=0; + for(int i=0;i>=1;cny>>=1; + for(int i=0;i que; +bool oor(int x,int y) +{ + if(x<0||x>=cnx) return false; + if(y<0||y>=cny) return false; + return true; +} +int dx[] = {-1,0,1,0}; +int dy[] = {0,1,0,-1}; +int dis[N][N][4]; +bool in[N][N][4]; +void solve() +{ + memset(in,0,sizeof(in)); + memset(dis,INF,sizeof(dis)); + while(!que.empty()) que.pop(); + int stx=mpx[st.x]/2,sty=mpy[st.y]/2,enx=mpx[en.x]/2,eny=mpy[en.y]/2; + for(int i=0;i<4;i++) + { + que.push((stx<<12)|(sty<<2)|i); + dis[stx][sty][i]= 0; + } + while(!que.empty()) + { + int e = que.front(); que.pop(); + int ed,ex,ey; + ed = e&3;e>>=2; + ey = e&1023;e>>=10; + ex = e; + in[ex][ey][ed] = false; + for(int i=0;i<4;i++) + { + int tx=ex+dx[i],ty=ey+dy[i]; + if(i==ed&&oor(tx,ty)&&can[ex][ey][ed][i]&&dis[tx][ty][i]>dis[ex][ey][ed]) + { + dis[tx][ty][i]=dis[ex][ey][ed]; + if(!in[tx][ty][i]) que.push((tx<<12)|(ty<<2)|i); + } + else if(i!=ed&&oor(tx,ty)&&can[ex][ey][ed][i]&&dis[tx][ty][i]>dis[ex][ey][ed]+1) + { + dis[tx][ty][i]=dis[ex][ey][ed]+1; + if(!in[tx][ty][i]) que.push((tx<<12)|(ty<<2)|i); + } + } + } + int ans=INF; + for(int i=0;i<4;i++) + ans = min(dis[enx][eny][i],ans); + printf("%d\n",ans==INF?-1:ans); +} +int main() +{ + while(~scanf("%d%d%d%d",&st.x,&st.y,&en.x,&en.y)) + { + if(st.x==0&&st.y==0&&en.x==0&&en.y==0) break; + st.x<<=1;st.y<<=1;en.x<<=1;en.y<<=1; + re[0][0] = st; + re[0][1] = en; + scanf("%d",&n);n+=1; + for(int i=1;ire[i][1].x) swap(re[i][0].x,re[i][1].x); + if(re[i][0].y>re[i][1].y) swap(re[i][0].y,re[i][1].y); + } + init(); + solve(); + } + return 0; +} diff --git a/HDOJ/4445_autoAC.cpp b/HDOJ/4445_autoAC.cpp new file mode 100644 index 0000000..01b6608 --- /dev/null +++ b/HDOJ/4445_autoAC.cpp @@ -0,0 +1,37 @@ +#include +#include +const double PI=acos(-1.0); +const double eps=PI/276; +int n; +double h,l1,r1,l2,r2,v[200]; +int cal(double x) +{ + int i,c=0; + for(i=0;i=l2&&s<=r2) return 0; + if(s>=l1&&s<=r1) c++; + } + return c; +} +int main() +{ + int i,ans; + while(scanf("%d",&n),n) + { + scanf("%lf%lf%lf%lf%lf",&h,&l1,&r1,&l2,&r2); + for(i=0;ians) ans=tmp; + j+=eps; + } + printf("%d\n",ans); + } + return 0; +} diff --git a/HDOJ/4446_autoAC.cpp b/HDOJ/4446_autoAC.cpp new file mode 100644 index 0000000..eaef64a --- /dev/null +++ b/HDOJ/4446_autoAC.cpp @@ -0,0 +1,127 @@ +#include +#include +#include +#define lson l,m,rt<<1 +#define rson m+1,r,rt<<1|1 +using namespace std; +const int ma=1000010; +const int inf=1<<25; +int n; +int c[ma<<2]; +int rc[ma]; +int add[ma<<2]; +int rrt; +void pushup(int rt) +{ + c[rt]=min(c[rt<<1],c[rt<<1|1]); +} +void pushdown(int rt,int m) +{ + if(add[rt]) + { + add[rt<<1]+=add[rt]; + add[rt<<1|1]+=add[rt]; + c[rt<<1]+=add[rt]; + c[rt<<1|1]+=add[rt]; + add[rt]=0; + } +} +void build(int l,int r,int rt) +{ + add[rt]=0; + if(l==r) + { + scanf("%d",&c[rt]); + return ; + } + int m=(l+r)>>1; + build (lson); + build (rson); + pushup(rt); +} +int query(int l,int r,int rt) +{ + if(l==r){rrt=rt;return l;} + pushdown(rt,r-l+1); + int m=(l+r)>>1; + if(c[rt<<1]<=c[rt<<1|1]) + return query(lson); + else return query(rson); +} +void update(int L,int R,int l,int r,int rt) +{ + if(L<=l&&r<=R) + { + add[rt]--; + c[rt]--; + return ; + } + pushdown(rt,r-1+1); + int m=(l+r)>>1; + if(L<=m) update(L,R,lson); + if(m>1; + if(p<=m)update2(p,lson); + else update2(p,rson); + pushup(rt); +} +int main() +{ + while(scanf("%d",&n),n) + { + int id=0; + int flag=0; + build(1,n,1); + queue a; + queue b; + while(a.size()+b.size()!=2*n) + { + int qq=query(1,n,1); + if(c[rrt]<0) + { + flag=1;break; + } + if(c[rrt]==0) + { + a.push(qq); + b.push(-qq); + if(qq!=1) + update(1,qq-1,1,n,1); + update2(qq,1,n,1); + } + else + { + if(b.size()==0){flag=1;break;} + int t=b.front(); + if(-t=0;i--) + printf("%d ",d[i]); + puts(""); + } + } + return 0; +} diff --git a/HDOJ/4447_autoAC.cpp b/HDOJ/4447_autoAC.cpp new file mode 100644 index 0000000..5325b26 --- /dev/null +++ b/HDOJ/4447_autoAC.cpp @@ -0,0 +1,124 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +const double eps(1e-8); +typedef long long lint; +#define maxn 1110 +vector v[maxn]; +struct polynomial +{ + int coe[maxn]; + int len; + polynomial() + { + memset(coe, 0, sizeof(coe)); + len = 1; + } + void output() + { + printf("("); + for(int i = len - 1; i >= 0; i--) + { + if(coe[i] == 0) continue; + if(i == 0) + { + if(coe[i] > 0) printf("+"); + printf("%d", coe[i]); + continue; + } + if(coe[i] > 0 && i != len - 1) printf("+"); + if(coe[i] == -1) printf("-"); + if(abs(coe[i]) != 1) printf("%d", coe[i]); + if(i > 1) + printf("x^%d", i); + else printf("x"); + } + printf(")"); + return; + } + polynomial operator / (const polynomial pol); +}; +polynomial polynomial :: operator / (const polynomial pol) +{ + polynomial ret; + ret.len = len - pol.len + 1; + for(int i = len - 1; i >= pol.len - 1; i--) + { + int tim = coe[i] / pol.coe[pol.len - 1]; + if(tim != 0) + { + for(int j = 0; j < pol.len; j++) + coe[i - j] -= tim*pol.coe[pol.len - 1 - j]; + ret.coe[i - pol.len + 1] = tim; + } + } + return ret; +} +polynomial p[maxn]; +bool cmp(int i, int j) +{ + if(p[i].len != p[j].len) return p[i].len < p[j].len; + for(int k = p[i].len - 1; k >= 0; k--) + if(p[i].coe[k] != p[j].coe[k]) + { + if(abs(p[i].coe[k]) == abs(p[j].coe[k])) + return p[i].coe[k] < 0; + else return abs(p[i].coe[k]) < abs(p[j].coe[k]); + } + return false; +} +int main() +{ + p[1].coe[0] = -1; + p[1].coe[1] = 1; + p[1].len = 2; + for(int i = 2; i <= 1100; i++) + { + p[i].coe[0] = -1; + p[i].coe[i] = 1; + p[i].len = i + 1; + p[i] = p[i]/p[1]; + v[i].push_back(1); + for(int j = 2; j*j <= i; j++) + { + if(i % j == 0) + { + p[i] = p[i]/p[j]; + v[i].push_back(j); + if(j*j != i) p[i] = p[i]/p[i / j], v[i].push_back(i / j); + } + } + v[i].push_back(i); + } + int n; + while(scanf("%d", &n), n) + { + if(n == 1) + { + printf("x-1\n"); + continue; + } + sort(v[n].begin(), v[n].end(), cmp); + for(int i = 0, sz = v[n].size(); i < sz; i++) + p[v[n][i]].output(); + printf("\n"); + } + return 0; +} diff --git a/HDOJ/4449_autoAC.cpp b/HDOJ/4449_autoAC.cpp new file mode 100644 index 0000000..f676d44 --- /dev/null +++ b/HDOJ/4449_autoAC.cpp @@ -0,0 +1,323 @@ +#include +#include +#include +#include +#include +using namespace std; +#define INF (1<<30) +#define PI acos(-1) +#define SET(a,b) memset(a,b,sizeof(a)) +#define M 10010 +#define N 505 +#define EPS 1e-8 +struct pt +{ + double x,y,z; + pt() {} + pt(double _x,double _y,double _z): x(_x),y(_y),z(_z) {} + pt operator - (const pt p1) + { + return pt(x-p1.x,y-p1.y,z-p1.z); + } + pt operator * (pt p) + { + return pt(y*p.z-z*p.y,z*p.x-x*p.z,x*p.y-y*p.x); + } + double operator ^ (pt p) + { + return x*p.x+y*p.y+z*p.z; + } +}; +struct _3DCH +{ + struct fac + { + int a,b,c; + bool ok; + }; + int n; + pt P[N]; + int cnt; + fac F[N*8]; + int to[N][N]; + double vlen(pt a) + { + return sqrt(a.x*a.x+a.y*a.y+a.z*a.z); + } + double area(pt a,pt b,pt c) + { + return vlen((b-a)*(c-a)); + } + double volume(pt a,pt b,pt c,pt d) + { + return (b-a)*(c-a)^(d-a); + } + double ptof(pt &p,fac &f) + { + pt m=P[f.b]-P[f.a],n=P[f.c]-P[f.a],t=p-P[f.a]; + return (m*n)^t; + } + void deal (int p,int a,int b) + { + int f=to[a][b]; + fac add; + if(F[f].ok) + if(ptof(P[p],F[f])>EPS) dfs(p,f); + else + { + add.a=b; add.b=a; add.c=p; add.ok=1; + to[p][b]=to[a][p]=to[b][a]=cnt; + F[cnt++]=add; + } + } + void dfs(int p,int cur) + { + F[cur].ok=0; + deal(p,F[cur].b,F[cur].a); + deal(p,F[cur].c,F[cur].b); + deal(p,F[cur].a,F[cur].c); + } + bool same(int s,int t) + { + pt &a=P[F[s].a],&b=P[F[s].b],&c=P[F[s].c]; + return fabs(volume(a,b,c,P[F[t].a]))EPS) + { + swap(P[1],P[i]); + sb=0; + break; + } + if(sb) return; sb=1; + for(int i=2;iEPS) + { + swap(P[2],P[i]); + sb=0; + break; + } + if(sb) return; sb=1; + for(int i=3;iEPS) + { + swap(P[3],P[i]); + sb=0; + break; + } + if(sb) return; + fac add; + for(int i=0;i<4;i++) + { + add.a=(i+1)%4; + add.b=(i+2)%4; + add.c=(i+3)%4; + add.ok=1; + if(ptof(P[i],add)>0) swap(add.b,add.c); + to[add.a][add.b]=to[add.b][add.c]=to[add.c][add.a]=cnt; + F[cnt++]=add; + } + for(int i=4;iEPS) + { + dfs(i,j); + break; + } + int tmp=cnt; + cnt=0; + for(int i=0;iEPS) return 1; + if(d<-EPS) return -1; + return 0; +} +struct point +{ + double x,y,z; + point(double x=0,double y=0,double z=0): x(x),y(y),z(z) {} + point operator - (point p) + { + return point(x-p.x,y-p.y,z-p.z); + } + point operator + (point p) + { + return point(x+p.x,y+p.y,z+p.z); + } + point operator / (double len) + { + return point(x/len,y/len,z/len); + } + point operator * (double len) + { + return point(x*len,y*len,z*len); + } + double operator ^ (point p) + { + return x*p.x+y*p.y+z*p.z; + } + point operator * (point p) + { + return point(y*p.z-z*p.y,z*p.x-x*p.z,x*p.y-y*p.x); + } + double getlen() + { + return sqrt(x*x+y*y+z*z); + } +}con[N],ps[N],org; +double a,b,c,d; +int n; +inline point get_point(point u,point v,point p) +{ + double a,b,t; + a=(v.x-u.x)*(v.x-u.x)+(v.y-u.y)*(v.y-u.y)+(v.z-u.z)*(v.z-u.z); + b=(p.x-u.x)*(v.x-u.x)+(p.y-u.y)*(v.y-u.y)+(p.z-u.z)*(v.z-u.z); + t=b/a; + point ans; + ans.x=v.x*t+(1-t)*u.x; + ans.y=v.y*t+(1-t)*u.y; + ans.z=v.z*t+(1-t)*u.z; + return ans; +} +inline double dist(point a,point b) +{ + return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y)+(a.z-b.z)*(a.z-b.z)); +} +point rotate(point u,point v,point p,double ang) +{ + point root=get_point(u,v,p),e,r; + point ans; + e=(v-u)/dist(u,v); + r=p-root; + e=e*r; + ans=r*cos(ang)+e*sin(ang)+root; + return ans; +} +double inter_pro(point u1,point v1,point u2,point v2) +{ + return (v1.x-u1.x)*(v2.y-u2.y)-(v1.y-u1.y)*(v2.x-u2.x); +} +bool cmp(point a,point b) +{ + return a.y 0 && inter_pro(con[top - 1], con[top], con[top - 1], pol[i]) <= 0) top--; + con[++top] = pol[i]; + } + int tmp = top; + for(int i = n - 2; i >= 0; i--){ + while(top > tmp && inter_pro(con[top - 1], con[top], con[top - 1], pol[i]) <= 0) top--; + con[++top] = pol[i]; + } + len = top; +} +double polyArea(point* ps, int n){ + ps[n] = ps[0]; + int i; + double ans=0; + for(i = 0; i < n; i++){ + ans += (ps[i].x*ps[i+1].y-ps[i].y*ps[i+1].x); + } + return fabs(ans/2.0); +} +double solve() +{ + point tp(0,0,0),end(0,0,1),vec; + double ang; + int i,cn; + if(sign(a)) tp.x=d/a; + else if(sign(b)) tp.y=d/b; + else if(sign(c)) tp.z=d/c; + ps[n+1]=tp; + vec=(point(a,b,c))*(end); + if(sign(vec.x)==0) vec.x=0; + if(sign(vec.y)==0) vec.y=0; + if(sign(vec.z)==0) vec.z=0; + ang=(a*end.x+b*end.y+c*end.z)/(point(a,b,c).getlen()); + ang=acos(ang); + if(sign(ang)!=-0 && sign(ang-PI)!=0) + for(i=0;ians1) ans1=dist,ans2=ans; + else if(fabs(dist-ans1)ans) ans1=dist,ans2=ans; + } + printf("%.3f %.3f\n",ans1,ans2); + } + return 0; +} diff --git a/HDOJ/4450_autoAC.cpp b/HDOJ/4450_autoAC.cpp new file mode 100644 index 0000000..888473b --- /dev/null +++ b/HDOJ/4450_autoAC.cpp @@ -0,0 +1,12 @@ +#include +int main() +{ + int n,i,s,a; + while(scanf("%d",&n),n) + { + s=0; + while(n--){scanf("%d",&a);s+=a*a;} + printf("%d\n",s); + } + return 0; +} diff --git a/HDOJ/4451_autoAC.cpp b/HDOJ/4451_autoAC.cpp new file mode 100644 index 0000000..58114e1 --- /dev/null +++ b/HDOJ/4451_autoAC.cpp @@ -0,0 +1,31 @@ +#include +#include +int v1[1001],v2[1001]; +int main() +{ + int n,m,k,x,y,p; + char s1[10],s2[10]; + while(scanf("%d%d%d",&n,&m,&k),n||m||k) + { + memset(v1,0,sizeof(v1)); + memset(v2,0,sizeof(v2)); + int ans=n*m*k; + scanf("%d",&p); + while(p--) + { + scanf("%s%d%s%d",s1,&x,s2,&y); + if(s1[0]=='c') + { + v1[y]++; + ans-=(k-v2[y]); + } + else + { + v2[x]++; + ans-=(n-v1[x]); + } + } + printf("%d\n",ans); + } + return 0; +} diff --git a/HDOJ/4452_autoAC.cpp b/HDOJ/4452_autoAC.cpp new file mode 100644 index 0000000..d8f77ec --- /dev/null +++ b/HDOJ/4452_autoAC.cpp @@ -0,0 +1,129 @@ +#include +using namespace std; +int f[4][2]={-1,0,0,-1,1,0,0,1}; +int n; +int x_1,y_1,x_2,y_2; +int dis_1,speed_1,time_1; +int dis_2,speed_2,time_2; +inline int Get_f(char f) +{ + if(f=='N') + return 0; + else if(f=='W') + return 1; + else if(f=='S') + return 2; + else + return 3; +} +void Get_next(int &x,int &y,int speed,int &dis) +{ + int temp=2*(n-1); + speed%=temp; + x+=speed*f[dis][0]; + y+=speed*f[dis][1]; + if(f[dis][0]) + { + if(x<=0) + { + x+=temp; + dis=2; + if(x>n&&x<=temp) + { + x=2*n-x; + } + } + else if(x>temp) + { + x-=temp; + dis=0; + if(x>n&&x<=temp) + { + x=2*n-x; + } + } + else if(x>n&&x<=temp) + { + x=2*n-x; + dis=0; + } + } + else + { + if(y<=0) + { + y+=temp; + dis=3; + if(y>n&&y<=temp) + { + y=2*n-y; + } + } + else if(y>temp) + { + y-=temp; + dis=1; + if(y>n&&y<=temp) + { + y=2*n-y; + } + } + else if(y>n&&y<=temp) + { + y=2*n-y; + dis=1; + } + } +} +void run(int k) +{ + int t_1=0; + int t_2=0; + x_1=y_1=1; + x_2=y_2=n; + while(k--) + { + Get_next(x_1,y_1,speed_1,dis_1); + Get_next(x_2,y_2,speed_2,dis_2); + t_1++; + t_2++; + if(x_1==x_2&&y_1==y_2) + { + int temp=dis_1; + dis_1=dis_2; + dis_2=temp; + t_1%=time_1; + t_2%=time_2; + continue; + } + if(t_1==time_1) + { + dis_1++; + dis_1%=4; + } + if(t_2==time_2) + { + dis_2++; + dis_2%=4; + } + t_1%=time_1; + t_2%=time_2; + } +} +int main() +{ + int k; + char temp_1[2],temp_2[2]; + while(scanf("%d",&n)!=EOF&&n) + { + scanf("%s%d%d",&temp_1,&speed_1,&time_1); + scanf("%s%d%d",&temp_2,&speed_2,&time_2); + dis_1=Get_f(temp_1[0]); + dis_2=Get_f(temp_2[0]); + scanf("%d",&k); + run(k); + printf("%d %d\n",x_1,y_1); + printf("%d %d\n",x_2,y_2); + } + return 0; +} diff --git a/HDOJ/4453_autoAC.cpp b/HDOJ/4453_autoAC.cpp new file mode 100644 index 0000000..2a5c4ed --- /dev/null +++ b/HDOJ/4453_autoAC.cpp @@ -0,0 +1,207 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +typedef long long LL; +typedef pair PII; +#define LL(x) (ch[x][0]) +#define RR(x) (ch[x][1]) +#define Kt (ch[ ch[Rt][1] ][0]) +#define MID(a,b) (a+((b-a)>>1)) +const int N=1e6+5; +int n,m,k1,k2; +int a[N/2]; +struct SplayTree +{ + int Rt,top; + int pre[N],sz[N],ch[N][2]; + int key[N],add[N],pos; + bool flip[N]; + inline void Link(int x,int y,int f) + { + pre[x]=y; if(y) ch[y][f]=x; + } + inline void Rotate(int x,int f) + { + int y=pre[x],z=pre[y]; + PushDown(y); PushDown(x); + Link(x,z,RR(z)==y); + Link(ch[x][f],y,!f); + Link(y,x,f); + PushUp(y); + } + inline void Splay(int x,int goal) + { + while(pre[x]!=goal) + { + int y=pre[x],z=pre[y]; + int cx=(LL(y)==x),cy=(LL(z)==y); + if(z==goal) Rotate(x,cx); + else + { + if(cx==cy) Rotate(y,cy); + else Rotate(x,cx); + Rotate(x,cy); + } + } + PushUp(x); + if(goal==0) Rt=x; + } + inline void Select(int K,int goal) + { + int x=Rt; + PushDown(x); + while(1) + { + if(sz[LL(x)]>=K) x=LL(x); + else if(sz[LL(x)]+1==K) break; + else K-=sz[LL(x)]+1,x=RR(x); + PushDown(x); + } + Splay(x,goal); + } + inline void fun_add(int x,int valu) + { + add[x]+=valu; + key[x]+=valu; + } + inline void fun_flip(int x) + { + flip[x]^=1; + swap(LL(x),RR(x)); + } + inline void PushDown(int x) + { + if(add[x]) + { + fun_add(LL(x),add[x]); + fun_add(RR(x),add[x]); + add[x]=0; + } + if(flip[x]) + { + fun_flip(LL(x)); + fun_flip(RR(x)); + flip[x]=0; + } + } + inline void PushUp(int x) + { + sz[x]=1+sz[LL(x)]+sz[RR(x)]; + } + inline void Add(int x) + { + Select(1,0); Select(k2+2,Rt); + fun_add(Kt,x); + } + inline void Reverse() + { + Select(1,0); Select(k1+2,Rt); + fun_flip(Kt); + } + inline void Insert(int x,int pos) + { + Select(pos,0); Select(pos+1,Rt); + addNode(x,Kt,RR(Rt)); + PushUp(RR(Rt)); PushUp(Rt); + } + inline int Delete(bool top) + { + int valu; + if(top) + { + Select(1,0); Select(3,Rt); + valu=key[Kt]; + Kt=0; + PushUp(RR(Rt)); PushUp(Rt); + } + else + { + int len=sz[Rt]; + Select(len-2,0);Select(len,Rt); + valu=key[Kt]; + Kt=0; + PushUp(RR(Rt)); PushUp(Rt); + } + return valu; + } + inline void Move(int x) + { + if(x==1) + { + int valu=Delete(0); + Insert(valu,1); + } + else + { + int valu=Delete(1); + Insert(valu,sz[Rt]-1); + } + } + inline void Query() + { + Select(2,0); + printf("%d\n",key[Rt]); + } + void addNode(int valu,int &x,int f) + { + x=++top; + pre[x]=f; sz[x]=1; LL(x)=RR(x)=0; + key[x]=valu; add[x]=flip[x]=0; + } + void build(int lft,int rht,int &x,int f) + { + if(lft>rht) return; + int mid=MID(lft,rht); + addNode(a[mid],x,f); + build(lft,mid-1,LL(x),x); + build(mid+1,rht,RR(x),x); + PushUp(x); + } + void init() + { + Rt=top=0; + pre[0]=sz[0]=LL(0)=RR(0)=0; + addNode(0,Rt,0); addNode(0,RR(Rt),Rt); + build(0,n-1,Kt,RR(Rt)); + PushUp(RR(Rt)); PushUp(Rt); + } +}spt; +int main() +{ + int t_cnt=0; + while(scanf("%d%d%d%d",&n,&m,&k1,&k2)!=EOF) + { + if(n==0&&m==0&&k1==0&&k2==0) break; + for(int i=0;i +#include +#include +#include +#include +#include +using namespace std; +const double eps = 1e-6; +const double PI = acos(-1.0); +double cx, cy, cr; +inline int sign(double x) { + return x < -eps ? -1 : x > eps ? 1 : 0; +} +struct Point { + double x, y; + Point (double xx = 0, double yy = 0) : x(xx), y(yy) {} + Point operator - (const Point &ot) const { + return Point(x - ot.x , y - ot.y); + } + double operator * (const Point &ot) const { + return x * ot.x + y * ot.y; + } + double operator ^ (const Point &ot) const { + return x * ot.y - y * ot.x; + } + bool operator < (const Point &ot) const { + if (sign(x - ot.x)) { + return sign(x - ot.x) < 0; + } else { + return sign(y - ot.y) < 0; + } + } + void show() { + printf("x = %.2f, y = %.2f\n", x, y); + } +}; +Point it, rp[4]; +double dist(const Point &a, const Point &b) { + return sqrt((a.x-b.x)*(a.x-b.x) + (a.y-b.y)*(a.y-b.y)); +} +double dtoL(const Point &np, const Point &st, const Point &ed) { + double ret; + if (sign((ed-st)*(np-st)) > 0 && sign((st-ed)*(np-ed) > 0)) { + ret = fabs((st-np)^(ed-np)) / dist(st, ed); + } else { + ret = min(dist(np, st), dist(np, ed)); + } + return ret; +} +double dtoR(const Point &np) { + double d1 = min(dtoL(np, rp[0], rp[1]), dtoL(np, rp[0], rp[2])); + double d2 = min(dtoL(np, rp[1], rp[3]), dtoL(np, rp[2], rp[3])); + return min(d1, d2); +} +double tsearch(double l, double r) { + double delta; + while (r - l >= eps) { + delta = (r - l) / 3.0; + Point Lp(cr*cos(l+delta), cr*sin(l+delta)); + Point Rp(cr*cos(r-delta), cr*sin(r-delta)); + double d1 = dist(it, Lp) + dtoR(Lp); + double d2 = dist(it, Rp) + dtoR(Rp); + if (sign(d1 - d2) > 0) { + l += delta; + } else { + r -= delta; + } + } + Point fp(cr*cos(r), cr*sin(r)); + return dist(it, fp) + dtoR(fp); +} +void solve() { + printf("%.2f\n", min(tsearch(0, PI), tsearch(PI, 2*PI))); +} +int main() { + while (scanf("%lf %lf", &it.x, &it.y), sign(it.x) | sign(it.y)) { + scanf("%lf %lf %lf", &cx, &cy, &cr); + it.x -= cx, it.y -= cy; + scanf("%lf %lf", &rp[0].x, &rp[0].y); + rp[0].x -= cx, rp[0].y -= cy; + scanf("%lf %lf", &rp[1].x, &rp[1].y); + rp[1].x -= cx, rp[1].y -= cy; + rp[2].x = rp[0].x, rp[2].y = rp[1].y; + rp[3].x = rp[1].x, rp[3].y = rp[0].y; + sort(rp, rp+4); + double t = sqrt(2.0) / 2; + solve(); + } + return 0; +} diff --git a/HDOJ/4455_autoAC.cpp b/HDOJ/4455_autoAC.cpp new file mode 100644 index 0000000..234a1da --- /dev/null +++ b/HDOJ/4455_autoAC.cpp @@ -0,0 +1,56 @@ +#include +#include +#include +#include +#include +using namespace std; +typedef __int64 LL; +const int maxn=1e6+10; +int c[maxn],a[maxn],pre[maxn],sum[maxn],num[maxn]; +LL dp[maxn]; +int main() +{ + int n,m; + while(scanf("%d",&n)!=EOF) + { + if(n==0)break; + int i,j,k,t; + for(i=1;i<=n;i++) + scanf("%d",&a[i]); + memset(c,0,sizeof(c)); + memset(pre,0,sizeof(pre)); + for(i=1;i<=n;i++) + { + c[i-pre[a[i]]]++; + pre[a[i]]=i; + } + sum[n]=c[n]; + for(i=n-1;i>=1;i--) + sum[i]=sum[i+1]+c[i]; + memset(c,0,sizeof(c)); + num[1]=1; + c[a[n]]++; + for(i=2;i<=n;i++) + { + if(c[a[n-i+1]]==0) + { + num[i]=num[i-1]+1; + c[a[n-i+1]]=1; + } + else + num[i]=num[i-1]; + } + dp[1]=n; + for(i=2;i<=n;i++) + { + dp[i]=dp[i-1]-num[i-1]+sum[i]; + } + scanf("%d",&m); + for(i=0;i +#include +#include +#include +#include +#define MAXN 4001003 +#define MAXM 88888 +using namespace std; +int n, m; +int W; +int h[MAXN], cnt; +int a[MAXN]; +int pp[MAXN], xx[MAXN], yy[MAXN], zz[MAXN]; +inline int lowbit(int x) +{ + return x & -x; +} +void ready(int x, int y) +{ + for (int i = x; i <= W; i += lowbit(i)){ + for (int j = y; j <= W; j += lowbit(j)) { + h[cnt++] = i * W + j; + } + } +} +void add(int x, int y, int val) +{ + for(int i = x; i <= W; i += lowbit(i)) + for(int j = y; j <= W; j += lowbit(j)) + { + int pos = lower_bound(h, h + cnt, i * W + j) - h; + a[pos] += val; + } +} +int getsum(int x, int y) +{ + int sum = 0; + for(int i = x; i > 0; i -= lowbit(i)) + for(int j = y; j > 0; j -= lowbit(j)) + { + int pos = lower_bound(h, h + cnt, i * W + j) - h; + if(h[pos] == i * W + j) + sum += a[pos]; + } + return sum; +} +int main() +{ + int p, x, y, z, xa, xb, ya, yb, newx, newy; + while(scanf("%d", &n) != EOF && n) + { + scanf("%d", &m); + W = n * 2; + cnt = 0; + memset(a, 0, sizeof(a)); + for (int i = 0; i < m; i++) + { + scanf("%d%d%d%d", &pp[i], &xx[i], &yy[i], &zz[i]); + newx = xx[i] - yy[i] + n; + newy = xx[i] + yy[i]; + if (pp[i] == 1) + ready(newx, newy); + } + sort(h, h + cnt); + cnt = unique(h, h + cnt) - h; + for(int i = 0; i < m; i++) + { + newx = xx[i] - yy[i] + n; + newy = xx[i] + yy[i]; + if(pp[i] == 1) add(newx, newy, zz[i]); + else + { + xa = max(1, newx - zz[i]); + ya = max(1, newy - zz[i]); + xb = min(W, newx + zz[i]); + yb = min(W, newy + zz[i]); + printf("%d\n", getsum(xb, yb) - getsum(xa - 1, yb) - getsum(xb, ya - 1) + getsum(xa - 1, ya - 1)); + } + } + } + return 0; +} diff --git a/HDOJ/4458_autoAC.cpp b/HDOJ/4458_autoAC.cpp new file mode 100644 index 0000000..f8c2520 --- /dev/null +++ b/HDOJ/4458_autoAC.cpp @@ -0,0 +1,102 @@ +#include +#include +#include +#include +#include +using namespace std; +const double EPS=1e-8; +const int maxn=100; +int n; +struct Point +{ + double x,y; + Point (double x=0,double y=0):x(x),y(y){} +}; +Point poly[maxn]; +typedef Point Vector; +Vector operator + (Vector A,Vector B) {return Vector(A.x+B.x,A.y+B.y);} +Vector operator - (Point A,Point B) {return Vector(A.x-B.x,A.y-B.y);} +Vector operator * (Vector A,double p) {return Vector(A.x*p,A.y*p);} +Vector operator / (Vector A,double p) {return Vector(A.x/p,A.y/p);} +bool operator < (const Point &a,const Point &b){ + return a.x < b.x ||(a.x==b.x &&a.y < b.y); +} +int dcmp (double x){ + if(fabs(x)0 && d1<=0 && d2>0) wn++; + if(k<0 && d2<=0 && d1>0) wn--; + } + if(wn!=0) return 1; + return 0; +} +int main() +{ + double v,b,g; + while (scanf("%lf %lf %lf",&v,&b,&g),v||b||g) + { + v=-v; + scanf("%d",&n); + bool flag=false; + int i; + double minx=1e12,maxx=-1e12,maxy=-1e12; + for(i=0;imaxx) maxx=poly[i].x; + if(poly[i].xmaxy) maxy=poly[i].y; + } + double t; + for(int i=0;;i++) + { + t=i*0.001; + Point temp; + temp.x=v*t;temp.y=b*t-0.5*g*t*t; + if( isPointInPolygon(temp) ) + { + printf("%.2f\n",t-EPS); + flag=true; + break; + } + if(!g && temp.y>maxy) break; + if(temp.y<0) break; + } + if(!flag) printf("Miss!\n"); + } + return 0; +} diff --git a/HDOJ/4459_autoAC.cpp b/HDOJ/4459_autoAC.cpp new file mode 100644 index 0000000..0fa893e --- /dev/null +++ b/HDOJ/4459_autoAC.cpp @@ -0,0 +1,218 @@ +#include +#include +#include +#include +using namespace std; +typedef long long LL; +struct fac +{ + LL fz,fm; + fac(){} + fac (LL a,LL b):fz(a),fm(b) {} + fac fix() + { + LL d=__gcd(fz,fm); + return fac(fz/d,fm/d); + } + fac operator + (const fac & b) const { return fac(fz*b.fm+fm*b.fz,fm*b.fm).fix(); } + fac operator * (const fac & b) const { return fac(fz*b.fz,fm*b.fm).fix(); } + fac operator / (const fac & b) const { return fac(fz*b.fm,fm*b.fz).fix(); } + fac operator - (const fac & b) const { return fac(fz*b.fm-fm*b.fz,fm*b.fm).fix() ;} +}; +struct node +{ + fac xs; + int d[5],x[5]; + node () { + xs=fac(1,1); + for(int i=0;i<5;i++) { d[i]=x[i]=0;} + } + node operator * (const node & b) const { + node ans; + ans.xs=xs*b.xs; + for(int i=0;i<5;i++) { + ans.d[i]=d[i]+b.d[i]; + ans.x[i]=x[i]+b.x[i]; + } + return ans; + } + bool operator < (const node & b) const + { + for(int i=0;i<5;i++) { + if(d[i]!=b.d[i]) return d[i] dep[10],ans; +vector v_mult(vector & a,vector & b) +{ + vector ans; + int s1=a.size(),s2=b.size(); + for(int i=0;i v_exp(vector & a,int b) +{ + vector c=a; + while(--b){ + c=v_mult(c,a); + } + return c; +} +void init() +{ + node a; + dep[5].push_back(a); + for(int i=4;i>=0;i--){ + int s=dep[i+1].size(); + vector tmp; + node b; + b.d[i]=1; + tmp.push_back(b); + for(int j=0;j q=v_exp(tmp,dep[i+1][j].x[i]+1); + int s1=q.size(); + for(int k=0;k=0;i--) { + d[i]=min(d[i],d[i+1]); + if(d[i]<0) return; + } + fac p=cal(); + if(t) ans=ans+p; + else ans=ans-p; + return; + } + a[s]=1; + dfs(ans,s+1,1-t); + a[s]=0; + dfs(ans,s+1,t); +} +fac solve() +{ + while(n<5){ + tt[n].s2=1; + tt[n++].d=2000; + } + fac ans=fac(0,1); + dfs(ans,0,1); + for(int i=0;i<5;i++) ans.fm=ans.fm*tt[i].s2; + return ans.fix(); +} +int main() +{ + init(); + while(scanf("%d",&n)&&n){ + for(int i=0;itt[i].d) { flag=0;break;} + } + else { + tt[i-1].d=min(tt[i-1].d,tt[i].d-tt[i].s1); + } + for(int j=i;j=ans.fm) puts("Congratulations!"); + else printf("%I64d/%I64d\n",ans.fz,ans.fm); + } + } +} diff --git a/HDOJ/4460_autoAC.cpp b/HDOJ/4460_autoAC.cpp new file mode 100644 index 0000000..bb2f71d --- /dev/null +++ b/HDOJ/4460_autoAC.cpp @@ -0,0 +1,77 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +const int MAXN=1010; +const int INF=0x3f3f3f3f; +int dis[MAXN][MAXN]; +bool used[MAXN]; +vectorvec[MAXN]; +queueque; +void bfs(int i) +{ + memset(used,false,sizeof(used)); + dis[i][i]=0; + used[i]=true; + que.push(i); + while(!que.empty()) + { + int t=que.front(); + que.pop(); + int m=vec[t].size(); + for(int j=0;jdis[i][t]+1) + dis[i][v]=dis[i][t]+1; + que.push(v); + used[v]=true; + } + } +} +mapmp; +int main() { + string str; + string str2; + int n,m,i,j; + while(scanf("%d",&n)==1 && n) + { + mp.clear(); + for(i=0;i>str; + mp[str]=i; + } + for(i=0;i>str>>str2; + int t1=mp[str]; + int t2=mp[str2]; + vec[t1].push_back(t2); + vec[t2].push_back(t1); + } + for(i=0;idis[i][j]?ans:dis[i][j]; + if(ans==INF)ans=-1; + printf("%d\n",ans); + } + return 0; +} diff --git a/HDOJ/4462_autoAC.cpp b/HDOJ/4462_autoAC.cpp new file mode 100644 index 0000000..eefa380 --- /dev/null +++ b/HDOJ/4462_autoAC.cpp @@ -0,0 +1,76 @@ +#include +#include +#include +#include +using namespace std; +#define MAXN 60 +bool flag; +int n,m; +int x[20],y[20],r[20]; +int map[MAXN][MAXN]; +int node[MAXN],total; +void func() +{ + int L,R,T,D; + memset(map,0,sizeof(map)); + for(int i=1;i<=m;i++) + map[x[i]][y[i]]=1; + for(int i=0;i0?x[k]-r[k]:1); + R=(x[k]+r[k]<=n?x[k]+r[k]:n); + T=(y[k]-r[k]>0?y[k]-r[k]:1); + D=(y[k]+r[k]<=n?y[k]+r[k]:n); + for(int j=L;j<=R;j++) + for(int l=T;l<=D;l++) + if(abs(j-x[k])+abs(l-y[k])<=r[k]) + map[j][l]=1; + } + for(int i=1;i<=n;i++) + for(int j=1;j<=n;j++) + if(!map[i][j]) return; + flag=1; +} +void dfs(int sel,int cnt) +{ + if(sel==total) + func(); + else + for(int i=cnt;i<=m;i++) + { + node[sel]=i; + dfs(sel+1,i+1); + } +} +void solve() +{ + scanf("%d",&m); + for(int i=1;i<=m;i++) + scanf("%d%d",&x[i],&y[i]); + for(int i=1;i<=m;i++) + scanf("%d",&r[i]); + flag=0; + if(m>=n*n) + { + printf("0\n"); + return; + } + for(int i=1;i<=m;i++) + { + total=i; + dfs(0,1); + if(flag==1) + { + printf("%d\n",i); + return; + } + } + printf("-1\n"); +} +int main() +{ + while(~scanf("%d",&n) && n) + solve(); + return 0; +} diff --git a/HDOJ/4463_autoAC.cpp b/HDOJ/4463_autoAC.cpp new file mode 100644 index 0000000..a61057d --- /dev/null +++ b/HDOJ/4463_autoAC.cpp @@ -0,0 +1,70 @@ +#include"stdio.h" +#include"string.h" +#include"stdlib.h" +#include"math.h" +int pre[100]; +struct A +{ + int a,b,len; +}eage[3000]; +int k; +int x[100],y[100]; +void build(int n) +{ + int i; + for(i=0;ilen-d->len; +} +int main() +{ + int n; + int i,l; + int d1,d2; + int f1,f2; + double ans; + while(scanf("%d",&n),n) + { + build(n); + scanf("%d%d",&d1,&d2); + d1--;d2--; + for(i=0;i +#include +int main() { + int n, t = 0; + while(scanf("%d", &n)!=EOF) { + int maxx = 0; + while(n--) { + int i, tmp = 0; + char s[105]; + scanf("%s", s); + for(i = 0; s[i]; i++) + tmp += s[i]; + if(tmp > maxx) + maxx = tmp; + } + printf("Case %d: %d\n", ++t, maxx); + } + return 0; +} diff --git a/HDOJ/4465_autoAC.cpp b/HDOJ/4465_autoAC.cpp new file mode 100644 index 0000000..3cf2a32 --- /dev/null +++ b/HDOJ/4465_autoAC.cpp @@ -0,0 +1,30 @@ +#include +#include +#include +#define N 400200 +double f[N]; +double logc(int n,int m) +{ + return f[m]-f[n]-f[m-n]; +} +int main () +{ + int n; + int i,j,k=0; + double p,ans,ret; + f[0]=0; + for (i=1;i +#include +#include +#include +#define maxn 5000500 +#define M 1000000007 +#define ll long long +using namespace std; +ll f[maxn]; +ll count(ll x) +{ + ll tot=0; + for (int i=1; i<=x/3; i++) + { + int tep=x-i; + if (tep/2>=max(i,(tep-i)/2+1)) + { + tot=(tot+tep/2-max(i,(tep-i)/2+1)+1); + if (tot>=M) tot-=M; + } + } + return tot; +} +ll get(ll x) +{ + if (f[x]!=0) return f[x]; + ll tot=0; + for (int i=3; i<=x/2; i++) + if (x%i==0) + { + tot=(tot+get(i)); + if (tot>=M) tot-=M; + } + f[x]=count(x)-tot; + if (f[x]<0) f[x]+=M; + return f[x]; +} +ll power(ll x,ll y) +{ + ll tot=1; + while (y) + { + if (y&1) tot=(tot*x)%M; + x=(x*x)%M; + y>>=1; + } + return tot; +} +int main() +{ + ll n,ans,tep,cas=0; + while (scanf("%I64d",&n)!=EOF) + { + ans=0; + for (int i=1; i*i<=n; i++) + { + if (n%i==0) + { + tep=get(i); + tep=(tep*power(2,n/i-1))%M; + ans+=tep; + if (ans>=M) ans-=M; + if (i*i!=n) + { + tep=get(n/i); + tep=(tep*power(2,i-1))%M; + ans+=tep; + if (ans>=M) ans-=M; + } + } + } + printf("Case %I64d: %I64d\n",++cas,ans); + } + return 0; +} diff --git a/HDOJ/4467_autoAC.cpp b/HDOJ/4467_autoAC.cpp new file mode 100644 index 0000000..ac25b45 --- /dev/null +++ b/HDOJ/4467_autoAC.cpp @@ -0,0 +1,99 @@ +#include +#include +#include +#include +#include +#include +using namespace std; +typedef long long LL; +const int N = 101010; +int n, m; +LL ans[3], sum[N][2]; +vector c[N]; +vector lin[N]; +int color[N], key[N], deg[N]; +struct node{ + int a,b; LL c; + bool operator < (const node &tmp)const{ + return (a e[i].b ) swap( e[i].a, e[i].b ); + } + sort( e+1, e+m+1 ); + int t = 1; + for(int i = 2; i <= m; i++) + if( e[i].a != e[t].a || e[i].b != e[t].b ) e[++t] = e[i]; + else e[t].c += e[i].c; + m = t; + for(int i = 1; i <= m; i++){ + int a = e[i].a, b = e[i].b; + ans[ color[a]+color[b] ] += e[i].c; + deg[a]++; deg[b]++; + } + lim = round(sqrt(n)); + for(int i = 1; i <= n; i++) if( deg[i] > lim ) key[i] = 1; + for(int i = 1; i <= m; i++){ + int a = e[i].a, b = e[i].b; + sum[a][ color[b] ] += e[i].c; + sum[b][ color[a] ] += e[i].c; + if( key[a] && key[b] ){ + lin[a].push_back(b); c[a].push_back(e[i].c); + lin[b].push_back(a); c[b].push_back(e[i].c); + } + if( key[a] == 0 ) lin[a].push_back(b),c[a].push_back(e[i].c); + if( key[b] == 0 ) lin[b].push_back(a),c[b].push_back(e[i].c); + } +} +void change(int x){ + if( key[x] ){ + for(int i = 0; i < (int)(lin[x].size()); i++){ + sum[ lin[x][i] ][ color[x] ] -= c[x][i]; + sum[ lin[x][i] ][ color[x]^1 ] += c[x][i]; + } + } + else{ + sum[x][0] = sum[x][1] = 0; + for(int i = 0; i < (int)(lin[x].size()); i++){ + sum[x][ color[ lin[x][i] ] ] += c[x][i]; + if( key[ lin[x][i] ] ){ + sum[ lin[x][i] ][ color[x] ] -= c[x][i]; + sum[ lin[x][i] ][ color[x]^1 ] += c[x][i]; + } + } + } + ans[ color[x]+0 ] -= sum[x][0]; ans[ color[x]+1 ] -= sum[x][1]; + ans[ (color[x]^1)+0 ] += sum[x][0]; ans[ (color[x]^1)+1 ] += sum[x][1]; + color[x] ^= 1; +} +int main(){ + int Case = 1; + while( scanf("%d%d",&n,&m) != EOF){ + printf("Case %d:\n", Case++); + init(); + char op[110]; int Q, a, b; + scanf("%d", &Q ); + while( Q-- ){ + scanf("%s", op); + if( op[0] == 'A' ){ + scanf("%d%d",&a,&b); + printf("%I64d\n", ans[a+b] ); + } + else{ + scanf("%d",&a); + change( a ); + } + } + } + return 0; +} diff --git a/HDOJ/4468_autoAC.cpp b/HDOJ/4468_autoAC.cpp new file mode 100644 index 0000000..4d48ce8 --- /dev/null +++ b/HDOJ/4468_autoAC.cpp @@ -0,0 +1,77 @@ +#include +#include +#include +using namespace std; +#define MAXN 100005 +int ne[MAXN]; +char s[MAXN],p[MAXN]; +void getnext(int n,int st) +{ + for(int i=st+1;i +#include +using namespace std; +const int N =102; +const int mod = 1000000007; +int h; +struct matrix +{ + int row,col; + int m[N][N]; + void init(int row,int col) + { + this->row = row; + this->col = col; + for(int i=0; i<=row; ++i) + for(int j=0; j<=col; ++j) + m[i][j] = 0; + } +} A,pm[33],ans; +matrix operator*(const matrix & a,const matrix& b) +{ + matrix res; + res.init(a.row,b.col); + for(int k=1; k<=a.col; ++k) + { + for(int i=1; i<= res.row; ++i) + { + if(a.m[i][k] == 0 ) continue; + for(int j = 1; j<=res.col; ++j) + { + if(b.m[k][j] == 0 ) continue; + res.m[i][j] = (1LL *a.m[i][k]*b.m[k][j] + res.m[i][j])%mod; + } + } + } + return res; +} +void cal(int x) +{ + for(int i=0; i<=31; ++i) + if(x & (1<0; --i) scanf("%d",&f[i]); + scanf("%d",&t); + h =t; + for(int i=1; i<=t; ++i) scanf("%d",&c[i]); + for(int i=0; i h) h = p[i].tk; + for(int j=1; j<=p[i].tk; ++j) scanf("%d",&p[i].ck[j]); + } + sort(p,p+q); + A.init(h,h); + for(int i=1; i<=t; ++i) A.m[1][i] = c[i]; + for(int i=2; i<=h; ++i) A.m[i][i-1] = 1; + getPm(); + ans.init(h,1); + for(int i = m; i > 0; --i) ans.m[i][1] = f[i]; + int last=m; + for(int i=0; in ) continue; + cal( p[i].nk-last-1); + last = p[i].nk; + for(int j=1; j<=p[i].tk; ++j) A.m[1][j] = p[i].ck[j]; + for(int j=p[i].tk+1; j<=h; ++j) A.m[1][j] = 0; + ans =A*ans; + } + cal(n-last); + printf("Case %d: %d\n",++kase,ans.m[1][1]); + } + return 0; +} diff --git a/HDOJ/4472_autoAC.cpp b/HDOJ/4472_autoAC.cpp new file mode 100644 index 0000000..b45b29a --- /dev/null +++ b/HDOJ/4472_autoAC.cpp @@ -0,0 +1,25 @@ +#include +#include +#define N 1010 +#define MOD 1000000007 +long long dp[N]; +int n; +void DP() +{ + memset(dp,0,sizeof(dp)); + dp[1]=1; dp[2]=1; + for(int i=3; i<=1000; i++) + for(int j=1; j<=i-1; j++) + if((i-1)%j == 0) + dp[i] = (dp[i]+dp[j])%MOD; +} +int main() +{ + DP(); + int ccase=0; + while(scanf("%d",&n)!=EOF) + { + printf("Case %d: %lld\n",++ccase,dp[n]); + } + return 0; +} diff --git a/HDOJ/4473_autoAC.cpp b/HDOJ/4473_autoAC.cpp new file mode 100644 index 0000000..e15a530 --- /dev/null +++ b/HDOJ/4473_autoAC.cpp @@ -0,0 +1,38 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#define oo 1000000007 +#define MAXN 100005 +#define ll long long +#define pi acos(-1.0) +using namespace std; +ll n,i,j,k,ans=0; +int main() +{ + int cases=0; + while (~scanf("%I64d",&n)) + { + ans=0; + for (i=1;i*i*i<=n;i++) ans++; + for (i=1;i*i<=n;i++) + { + k=n/i/i; + if (k>=i) ans+=(k-1)*3; + else ans+=k*3; + } + for (i=1;i*i*i<=n;i++) + for (j=i+1;j<=n;j++) + { + k=n/i/j; + if (k>j) ans+=(k-j)*6; + else break; + } + printf("Case %d: %I64d\n",++cases,ans); + } + return 0; +} diff --git a/HDOJ/4474_autoAC.cpp b/HDOJ/4474_autoAC.cpp new file mode 100644 index 0000000..55f32a4 --- /dev/null +++ b/HDOJ/4474_autoAC.cpp @@ -0,0 +1,62 @@ +#include +#include +using namespace std; +struct{ + int m,f; + char c; +}d[10010],tmp; +int n,m,l,r; +bool h[10010],k[10]; +void out(int x){ + if(x==-1)return; + out(d[x].f); + putchar(d[x].c); +} +int main() +{ + int C=0; + while (~scanf("%d%d",&n,&m)){ + printf("Case %d: ",++C); + memset(h,true,sizeof(h)); + memset(k,true,sizeof(k)); + l=r=0; + for(int i=0;i +#include +#include +using namespace std; +const int con=1000003; +__int64 arr[con+1000]; +int main() +{ + int T; + __int64 n; + arr[0]=0; + arr[1]=2; + for(int i=2;i<=con;i++) + { + arr[i]=(arr[i-1]*2*i)%con; + } + scanf("%d",&T); + while(T--) + { + scanf("%I64d",&n); + if(n<=con) + printf("%I64d\n",arr[n%con]); + else printf("0\n"); + } + return 0; +} diff --git a/HDOJ/4476_autoAC.cpp b/HDOJ/4476_autoAC.cpp new file mode 100644 index 0000000..0fd3949 --- /dev/null +++ b/HDOJ/4476_autoAC.cpp @@ -0,0 +1,60 @@ +#include +#include +#include +#include +#include +#include +using namespace std; +const int MaxN = 200000; +int N; +int bit[MaxN+5]; +inline int lwb(int x) { + return x & -x; +} +void add(int x, int val) { + for (int i = x; i <= MaxN; i += lwb(i)) { + bit[i] += val; + } +} +int sum(int x) { + int ret = 0; + for (int i = x; i > 0; i -= lwb(i)) { + ret += bit[i]; + } + return ret; +} +int cal(int x) { + if (x <= MaxN/2) { + int k = x << 1; + return sum(k) - sum(k-1) + sum(MaxN) - sum(x - 1); + } else { + return sum(MaxN) - sum(x - 1); + } +} +char vis[100005]; +int que[100005]; +int tail; +int main() { + int T, x; + scanf("%d", &T); + while (T--) { + scanf("%d", &N); + tail = 0; + memset(bit, 0, sizeof (bit)); + memset(vis, 0, sizeof (vis)); + for (int i = 0; i < N; ++i) { + scanf("%d", &x); + add(x<<1, 1); + if (!vis[x]) { + vis[x] = 1; + que[tail++] = x; + } + } + int Max = 0; + for (int i = 0; i < tail; ++i) { + Max = max(Max, cal(que[i])); + } + printf("%d\n", Max); + } + return 0; +} diff --git a/HDOJ/4477_autoAC.cpp b/HDOJ/4477_autoAC.cpp new file mode 100644 index 0000000..c3dcbbf --- /dev/null +++ b/HDOJ/4477_autoAC.cpp @@ -0,0 +1,34 @@ +#include +#define N 50000 +#define M 1000000 +#define K 316 +int main() +{ + int dp[2][N+2]; + int ans[N+2]; + for(int i=3;i<=N;i++) + { + ans[i]=dp[0][i]=dp[0][i-2]+1; + } + for(int k=3;k<=K;k++) + { + int *p1=dp[k&1];int *p2=dp[(k+1)&1]; + for(int i=0;i<=k*(k+1)/2-1;i++) p1[i]=0; + for(int i=k*(k+1)/2;i<=N;i++) + { + p1[i]=p1[i-k]+p2[i-k]; + if(p1[i]>=M) + p1[i]-=M; + ans[i]+=p1[i]; + if(ans[i]>=M) + ans[i]-=M; + } + } + int t,n; + scanf("%d",&t); + while(t--) + { + scanf("%d",&n); + printf("%d\n",ans[n]); + } +} diff --git a/HDOJ/4478_autoAC.cpp b/HDOJ/4478_autoAC.cpp new file mode 100644 index 0000000..691ed65 --- /dev/null +++ b/HDOJ/4478_autoAC.cpp @@ -0,0 +1,81 @@ +#include +#include +#include +#include +#include +#include +using namespace std; +int N, T, sx, sy; +char mp[105][105]; +char vis[105][105][2]; +struct Sta { + int x, y, t; +}; +queueq; +int dir[8][2]={{-1,0},{-1,1},{0,1},{1,1},{1,0},{1,-1},{0,-1},{-1,-1}}; +inline bool judge(int x, int y) { + if (x >= 0 && x < N && y >= 0 && y < N) return true; + return false; +} +void cover(const Sta &cur) { + Sta nxt; + bool flag = false; + for (int k = 0; k < 8; ++k) { + nxt.x = cur.x + dir[k][0]; + nxt.y = cur.y + dir[k][1]; + nxt.t = cur.t + 1; + if (judge(nxt.x, nxt.y) && mp[nxt.x][nxt.y] == '.') { + flag = true; + if (!vis[nxt.x][nxt.y][nxt.t&1]) { + vis[nxt.x][nxt.y][nxt.t&1] = 1; + if (nxt.t < T) { + q.push(nxt); + } + } + } + } + if (!flag) { + nxt = cur; + ++nxt.t; + if (!vis[nxt.x][nxt.y][nxt.t&1]) { + vis[nxt.x][nxt.y][nxt.t&1] = 1; + if (nxt.t < T) { + q.push(nxt); + } + } + } +} +void solve() { + while (!q.empty()) q.pop(); + memset(vis, 0, sizeof (vis)); + Sta cur, nxt; + nxt.x = sx, nxt.y = sy, nxt.t = 0; + vis[sx][sy][0] = 1; + q.push(nxt); + while (!q.empty()) { + cur = q.front(), q.pop(); + cover(cur); + } + int odd = 0, even = 0; + for (int i = 0; i < N; ++i) { + for (int j = 0; j < N; ++j) { + if (vis[i][j][0]) ++even; + if (vis[i][j][1]) ++odd; + } + } + if (T & 1) printf("%d\n", odd); + else printf("%d\n", even); +} +int main() { + int C; + scanf("%d", &C); + while (C--) { + scanf("%d %d %d %d", &N, &T, &sx, &sy); + sx--, sy--; + for (int i = 0; i < N; ++i) { + scanf("%s", mp[i]); + } + solve(); + } + return 0; +} diff --git a/HDOJ/4479_autoAC.cpp b/HDOJ/4479_autoAC.cpp new file mode 100644 index 0000000..921f648 --- /dev/null +++ b/HDOJ/4479_autoAC.cpp @@ -0,0 +1,60 @@ +#include +#include +#include +#include +#include +using namespace std; +typedef long long LL; +int N, M; +struct Edge { + int x, y, d; + bool operator < (const Edge & ot) const { + return d < ot.d; + } +}e[50005]; +const LL INF = 0x3f3f3f3f3f3f3f3fLL; +LL dis[10005]; +struct Rec { + int v; + LL d; +}rec[10005]; +void update(int l, int r) { + int u, v, d, idx = 0; + for (int i = l; i <= r; ++i) { + u = e[i].x, v = e[i].y, d = e[i].d; + if (dis[u] != INF && dis[v] > dis[u] + d) { + rec[idx].v = v, rec[idx++].d = dis[u] + d; + } + if (dis[v] != INF && dis[u] > dis[v] + d) { + rec[idx].v = u, rec[idx++].d = dis[v] + d; + } + } + for (int i = 0; i < idx; ++i) { + dis[rec[i].v] = min(dis[rec[i].v], rec[i].d); + } +} +void solve() { + memset(dis, 0x3f, sizeof (dis)); + dis[1] = 0; + for (int i = 0, j; i < M; i = j) { + for (j = i + 1; j < M; ++j) { + if (e[j].d != e[i].d) break; + } + update(i, j-1); + } + if (dis[N] == INF) puts("No answer"); + else printf("%I64d\n", dis[N]); +} +int main() { + int T; + scanf("%d", &T); + while (T--) { + scanf("%d %d", &N, &M); + for (int i = 0; i < M; ++i) { + scanf("%d %d %d", &e[i].x, &e[i].y, &e[i].d); + } + sort(e, e + M); + solve(); + } + return 0; +} diff --git a/HDOJ/4483_autoAC.cpp b/HDOJ/4483_autoAC.cpp new file mode 100644 index 0000000..e63726e --- /dev/null +++ b/HDOJ/4483_autoAC.cpp @@ -0,0 +1,52 @@ +#include +#include +using namespace std; +#define maxn 100001 +#define LL long long +const LL mod=1000000007; +LL x[maxn],y[maxn],z[maxn],phi[maxn],n; +void init() +{ + LL i,j,k; + for(i=2;i>T; + while(T--) + { + LL k,t,ans,m; + cin>>n; + n++; + t=(n*n)%mod; + LL md=mod*6; + ans=t*(t-1)%md*(t-2)%md/6; + ans-=t*(n-1)%md*(n-2)*2%md/6; + t=0; + for(k=2;k +#include +#include +#include +using namespace std; +int cal(int n) { + int Max = n; + while (n!=1) { + if ((n&1) == 0) { + n /= 2; + } else { + n = n * 3 + 1; + } + if (n > Max) Max = n; + } + return Max; +} +void solve() { + int n; scanf("%d", &n); + int i, t, ca; + for (i = 0; i < n; ++i) { + scanf("%d%d", &t, &ca); + int ans = cal(ca); + printf("%d %d\n", t, ans); + } +} +int main(void) { + solve(); + return 0; +} diff --git a/HDOJ/4485_autoAC.cpp b/HDOJ/4485_autoAC.cpp new file mode 100644 index 0000000..7b4cda9 --- /dev/null +++ b/HDOJ/4485_autoAC.cpp @@ -0,0 +1,26 @@ +#include +#include +#include +#include +#include +using namespace std; +int p,a,b; +char s[10000000+1]; +int main() +{ + scanf("%d",&p); + while(p--) + { + scanf("%d%d%s",&a,&b,s); + int j=0; + int ans=0; + int l=strlen(s)-1; + for(int i=l;i>=0;i--) + { + ans+=(s[i]-'0')%(b-1); + ans%=b-1; + } + printf("%d %d\n",a,ans); + } + return 0; +} diff --git a/HDOJ/4486_autoAC.cpp b/HDOJ/4486_autoAC.cpp new file mode 100644 index 0000000..61a2b44 --- /dev/null +++ b/HDOJ/4486_autoAC.cpp @@ -0,0 +1,25 @@ +#include +#include +#include +#include +using namespace std; +int main() +{ + int cas; + scanf("%d",&cas); + while(cas--) + { + int id,n,tot=0; + scanf("%d %d",&id,&n); + if(n%3==0) tot++; + int top=(int)ceil(n*1.0/3); + for(int i=n/2;i>=top;i--) + { + if(n-i==i) continue; + if((n-i)&1) {tot+=(i-(n-i+1)/2+1)*2;tot--;} + else {tot+=(i-(n-i)/2+1)*2;tot-=2;} + } + printf("%d %d\n",id,tot); + } + return 0; +} diff --git a/HDOJ/4487_autoAC.cpp b/HDOJ/4487_autoAC.cpp new file mode 100644 index 0000000..4be3bc1 --- /dev/null +++ b/HDOJ/4487_autoAC.cpp @@ -0,0 +1,42 @@ +#include +#include +#include +#include +#include +#define LL long long +#define CLR(a, b) memset(a, b, sizeof(a)) +using namespace std; +const int N = 205; +double dp[2][N][N]; +int main() +{ + int t, n,cas;double L, R, ans; + scanf("%d", &t); + while(t --) + { + scanf("%d%d%lf%lf", &cas, &n, &L, &R); + CLR(dp, 0);dp[0][0][100] = 1; + for(int i = 1; i <= n; i ++) + { + CLR(dp[i&1], 0); + for(int j = 0; j <= i; j ++) + { + for(int k = 100 - i; k <= 100 + j; k ++) + { + dp[i&1][j][k] += dp[(i-1)&1][j][k-1] * R; + dp[i&1][j][k] += dp[(i-1)&1][j][k+1] * L; + dp[i&1][j][k] += dp[(i-1)&1][j][k] * (1.0 - L - R); + } + dp[i&1][j][100+j] += dp[(i-1)&1][j-1][99+j] * R; + } + }ans = 0; + for(int i = 0; i <= n; i ++) + { + for(int j = 100 - n; j <= 100 + n; j ++) + { + ans += i * dp[n&1][i][j]; + } + } + printf("%d %.4lf\n", cas, ans); + } +} diff --git a/HDOJ/4488_autoAC.cpp b/HDOJ/4488_autoAC.cpp new file mode 100644 index 0000000..fab7e8e --- /dev/null +++ b/HDOJ/4488_autoAC.cpp @@ -0,0 +1,66 @@ +#include +#include +#include +#include +#define N 100000 +using namespace std; +__int64 f[405][405][2],MIN,sum1,sum2; +__int64 getsMIN(__int64 x,__int64 y) +{ + x=(x<0)?-x:x; + y=(y<0)?-y:y; + __int64 t=x%y; + while(t!=0) + { + x=y; + y=t; + t=x%y; + } + return y; +} +int main() +{ + f[0][1][1]=1;f[0][1][2]=1; + f[1][2][1]=1;f[1][2][2]=2; + f[1][1][1]=1;f[1][1][2]=2; + int i,j,P,T,m,k,ans; + for(i=2;i<=400;i++) + { + for(j=i+1,sum1=0,sum2=1;j>1;j--) + { + f[i][j][1] = i*f[i-1][j-1][1]; + f[i][j][2] = j*f[i-1][j-1][2]; + MIN=getsMIN(f[i][j][1],f[i][j][2]); + f[i][j][1] /= MIN; + f[i][j][2] /= MIN; + if(sum2%f[i][j][2]) + { + sum1 = sum1*f[i][j][2]+f[i][j][1]*sum2; + sum2 *= f[i][j][2]; + } + else sum1 = sum1 + f[i][j][1]*(sum2/f[i][j][2]); + MIN=getsMIN(sum1,sum2); + sum1 /= MIN; + sum2 /= MIN; + } + f[i][1][2] = sum2; + f[i][1][1] = sum2-sum1; + MIN=getsMIN(f[i][1][1],f[i][1][2]); + f[i][1][1] /= MIN; + f[i][1][2] /= MIN; + } + scanf("%d",&P); + while(P--) + { + scanf("%d %d %d",&T,&m,&k); + if(!f[m][k][1]) + printf("%d 0\n",T); + else + { + if(f[m][k][2]==1) + printf("%d %I64d\n",T,f[m][k][1]); + else printf("%d %I64d/%I64d\n",T,f[m][k][1],f[m][k][2]); + } + } + return 0; +} diff --git a/HDOJ/4489_autoAC.cpp b/HDOJ/4489_autoAC.cpp new file mode 100644 index 0000000..08c4a12 --- /dev/null +++ b/HDOJ/4489_autoAC.cpp @@ -0,0 +1,43 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#define LL long long +#define mod 1000000007 +#define inf 0x3f3f3f3f +#define N 1000010 +#define clr(a) (memset(a,0,sizeof(a))) +using namespace std; +LL dp[21][2],ans[21],c[21][21]; +void init() +{ + for(int i=0;i<=20;i++)c[i][0]=c[i][i]=1; + for(int i=1;i<=20;i++) + for(int j=1;j +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +const int N = 100005; +const int M = 8; +const int INF = 0x3f3f3f3f; +const double eps = 1e-5; +const double PI = acos(-1.0); +typedef __int64 ll; +map mp[M][M]; +struct node +{ + int num[3]; + string ans; +}ss,now; +int lcm[3][3]; +int sa,sb,sc,ea,eb,ec; +struct wocao +{ + struct node t[N]; + int head,tail; + void init() + { + head = tail = 0; + } + bool empty() + { + return head == tail; + } + void push(struct node a) + { + t[tail] = a; + tail ++; + if(tail >= N) + tail -= N; + } + struct node front() + { + return t[head]; + } + void pop() + { + head ++; + if(head >= N) + head -= N; + } +}q; +void bfs() +{ + ss.ans.clear(); + ss.num[0] = sa;ss.num[1] = sb;ss.num[2] = sc; + for(int i = 0;i < M;i ++) + for(int j = 0;j < M;j ++) + mp[i][j].clear(); + mp[sa][sb][sc] = 1; + q.init(); + q.push(ss); + while(!q.empty()) + { + now = q.front(); + q.pop(); + int i; + for(i = 0;i < 3;i ++) + { + ss = now; + if(ss.num[i]) + { + ss.num[i] --; + ss.num[0] += lcm[i][0]; + ss.num[1] += lcm[i][1]; + ss.num[2] += lcm[i][2]; + if(ss.num[0] >= M || ss.num[1] >= M || ss.num[2] >= M) + continue; + if(mp[ss.num[0]][ss.num[1]].find(ss.num[2]) == mp[ss.num[0]][ss.num[1]].end()) + { + mp[ss.num[0]][ss.num[1]][ss.num[2]] = 1; + ss.ans += 'A' + i; + if(ss.num[0] == ea && ss.num[1] == eb && ss.num[2] == ec) + { + cout<= lcm[i][0] && ss.num[1] >= lcm[i][1] && ss.num[2] >= lcm[i][2]) + { + ss.num[0] -= lcm[i][0]; + ss.num[1] -= lcm[i][1]; + ss.num[2] -= lcm[i][2]; + ss.num[i] ++; + if(ss.num[0] >= M || ss.num[1] >= M || ss.num[2] >= M) + continue; + if(mp[ss.num[0]][ss.num[1]].find(ss.num[2]) == mp[ss.num[0]][ss.num[1]].end()) + { + mp[ss.num[0]][ss.num[1]][ss.num[2]] = 1; + ss.ans += 'a' + i; + if(ss.num[0] == ea && ss.num[1] == eb && ss.num[2] == ec) + { + cout< +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#define eps 1e-6 +#define INF 0x1f1f1f1f +#define PI acos(-1.0) +#define ll __int64 +#define lson l,m,(rt<<1) +#define rson m+1,r,(rt<<1)|1 +using namespace std; +struct Point +{ + double x,y; +}pp[22],p1,p2,p3; +Point oa,ob; +double dis(Point a) +{ + return sqrt(a.x*a.x+a.y*a.y); +} +double dmult(Point a,Point b) +{ + return a.x*b.x+a.y*b.y; +} +double xmult(Point a,Point b) +{ + return a.x*b.y-a.y*b.x; +} +int main() +{ + int t,d,m,s,be,aa; + double an; + scanf("%d",&t); + while(t--) + { + scanf("%d%d%d%d%lf",&d,&m,&s,&be,&an); + an=(an/180.0)*PI; + for(int i=1;i<=m;i++) + scanf("%d%lf%lf",&aa,&pp[i].x,&pp[i].y); + int la=be; + oa.x=cos(an),oa.y=sin(an); + ob.x=-oa.x,ob.y=-oa.y; + int flag,find; + double Max; + printf("%d ",d); + while(s--) + { + Max=-120; + for(int i=1;i<=m;i++) + { + if(i==be||i==la) + continue; + Point tmp; + tmp.x=pp[i].x-pp[be].x; + tmp.y=pp[i].y-pp[be].y; + double tt=xmult(oa,tmp); + if(tt>0) + { + double t=dmult(oa,tmp)/dis(oa)/dis(tmp); + if(t>Max) + { + Max=t; + flag=1; + find=i; + } + } + else if(tt<0) + { + double t=dmult(ob,tmp)/dis(ob)/dis(tmp); + if(t>Max) + { + Max=t;flag=2;find=i; + } + } + } + printf("%d",find); + la=be; + be=find; + if(s) + putchar(' '); + else + putchar('\n'); + if(flag==1) + { + ob.x=pp[la].x-pp[be].x; + ob.y=pp[la].y-pp[be].y; + oa.x=-ob.x; + oa.y=-ob.y; + } + else + { + oa.x=pp[la].x-pp[be].x; + oa.y=pp[la].y-pp[be].y; + ob.x=-oa.x; + ob.y=-oa.y; + } + } + } + return 0; +} diff --git a/HDOJ/4492_autoAC.cpp b/HDOJ/4492_autoAC.cpp new file mode 100644 index 0000000..6eff3fc --- /dev/null +++ b/HDOJ/4492_autoAC.cpp @@ -0,0 +1,32 @@ +#include +#include +#include +using namespace std; +char str1[200]; +char str2[200]; +int main() +{ + int t; + scanf("%d",&t); + while(t--) + { + int d,n; + scanf("%d%*c",&d); + gets(str1); + int len=strlen(str1); + scanf(" %d",&n); + int p=0; + for(int i=0;i +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +int main() +{ + int T; + scanf("%d",&T); + while(T--) + { + double sum = 0; + double a; + for(int i = 0;i < 12;i++) + { + scanf("%lf",&a); + sum += a; + } + sum /= 12; + char str[1000]; + sprintf(str,"%.2f",sum); + int len = strlen(str); + if(str[len-2] == '0' && str[len-1] == '0') + str[len-3] = 0; + else if(str[len-1] == '0') + str[len-1] = 0; + printf("$%s\n",str); + } + return 0; +} diff --git a/HDOJ/4494_autoAC.cpp b/HDOJ/4494_autoAC.cpp new file mode 100644 index 0000000..dfc7604 --- /dev/null +++ b/HDOJ/4494_autoAC.cpp @@ -0,0 +1,151 @@ +#include +#include +#include +#include +#include +#define inf 100000000 +using namespace std; +const int Maxn = 600; +struct Edge{ + int v; + int val; + int cost; + int next; +}edge[Maxn*600]; +struct Point{ + double x,y; +}p[Maxn]; +int head[Maxn],n,m,k; +int e; +int dis[Maxn],pre[Maxn], pos[Maxn],sta[Maxn],en[Maxn],ty[Maxn][20],flow; +int que[Maxn*600]; +double d[Maxn][Maxn]; +bool vis[Maxn]; +void add(int u, int v, int val, int cost) +{ + edge[e].v = v; + edge[e].val = val; + edge[e].cost = cost; + edge[e].next = head[u]; + head[u] = e++; + edge[e].v = u; + edge[e].val = 0; + edge[e].cost = -cost; + edge[e].next = head[v]; + head[v] = e++; +} +double DIS(Point a,Point b) +{ + return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y)); +} +void init() +{ + memset(head,-1,sizeof(head)); + e=0; +} +bool spfa(int s, int t) +{ + int i; + memset(pre, -1, sizeof(pre)); + memset(vis, 0, sizeof(vis)); + int Head, tail; + Head = tail = 0; + for(i = 0; i < Maxn; i++) + dis[i] = inf; + que[tail++] = s; + pre[s] = s; + dis[s] = 0; + vis[s] = 1; + while(Head != tail) + { + int now = que[Head++]; + vis[now] = 0; + for(i=head[now]; i != -1; i = edge[i].next) + { + int adj = edge[i].v; + if(edge[i].val > 0 && dis[now] + edge[i].cost < dis[adj]) + { + dis[adj] = dis[now] + edge[i].cost; + pre[adj] = now; + pos[adj] = i; + if(!vis[adj]) + { + vis[adj] = 1; + que[tail++] = adj; + } + } + } + } + return pre[t] != -1; +} +int MinCostFlow(int s, int t) +{ + int i; + int cost = 0; + flow = 0; + while(spfa(s, t)) + { + int f = 100000000; + for(i = t; i != s; i = pre[i]) + if (edge[pos[i]].val < f) + f = edge[pos[i]].val; + flow += f; + cost += dis[t] * f; + for(i = t; i != s; i = pre[i]) + { + edge[pos[i]].val -= f; + edge[pos[i] ^ 1].val += f; + } + } + return cost; +} +void build(int type) +{ + int i,j; + init(); + for(i=2;i<=n;i++){ + add(1,i,ty[i][type],1); + add(i,i+2*n,ty[i][type],0); + add(1,i+n,ty[i][type],0); + add(i+2*n,3*n+1,ty[i][type],0); + for(j=2;j<=n;j++){ + if(sta[i]+en[i]+d[i][j]<=sta[j]){ + add(i+n,j+2*n,ty[i][type],0); + } + } + } +} +int solve() +{ + int i,j,u,v; + int ans=0; + for(i=1;i<=m;i++){ + build(i); + ans+=MinCostFlow(1,3*n+1); + } + return ans; +} +int main() +{ + int i,j,u,v,c,t; + scanf("%d",&t); + while(t--) + { + init(); + scanf("%d%d",&n,&m); + scanf("%lf%lf",&p[1].x,&p[1].y); + for(i=2;i<=n;i++){ + scanf("%lf%lf%d%d",&p[i].x,&p[i].y,&sta[i],&en[i]); + for(j=1;j<=m;j++){ + scanf("%d",&ty[i][j]); + } + } + for(i=1;i<=n;i++){ + for(j=i+1;j<=n;j++){ + d[i][j]=d[j][i]=DIS(p[i],p[j]); + } + } + printf("%d\n",solve()); + } + return 0; +} diff --git a/HDOJ/4495_autoAC.cpp b/HDOJ/4495_autoAC.cpp new file mode 100644 index 0000000..56aaf1d --- /dev/null +++ b/HDOJ/4495_autoAC.cpp @@ -0,0 +1,90 @@ +#include +#include +#include +#include +#include +#include +#define MAXN 505 +#define INF 1000000007 +using namespace std; +const int dir[4][2]={{1,1},{-1,1},{1,-1},{-1,-1}}; +int n, m,ans; +int dp[MAXN][MAXN][4],to[4]={3,2,1,0}; +char st[MAXN][MAXN]; +long long p[MAXN], r[MAXN][MAXN], c[MAXN][MAXN]; +void cal(int x,int y,int k) +{ + int now=dp[x][y][k]; + x+=dir[k][0],y+=dir[k][1]; + while(x>=0&&x=0&&y=now+2) + now+=2; + else ++now; + ans=max(now,ans); + x+=dir[k][0],y+=dir[k][1]; + } +} +long long ac1(int rr,int x,int y) +{ + int l=y-x+1; + if (!x) return r[rr][y]; + return r[rr][y]-r[rr][x-1]*p[l]; +} +long long ac2(int cc,int x,int y) +{ + int l=y-x+1; + if (!x) return c[cc][y]; + return c[cc][y]-c[cc][x-1]*p[l]; +} +int main() +{ + int cas; + scanf("%d",&cas); + p[0]=1; + for (int i=1;i<=500;i++) p[i]=p[i-1]*131; + while (cas--) + { + ans=1; + scanf("%d%d",&n,&m); + for (int i=0;i +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +const int MAXN = 10010; +int F[MAXN]; +int find(int x) +{ + if(F[x] == -1)return x; + return F[x] = find(F[x]); +} +pairp[100010]; +int ans[100010]; +int main() +{ + int n,m; + while(scanf("%d%d",&n,&m) == 2) + { + memset(F,-1,sizeof(F)); + for(int i = 1;i <= m;i++) + { + scanf("%d%d",&p[i].first,&p[i].second); + } + ans[m] = n; + for(int i = m;i > 1;i --) + { + int t1 = find(p[i].first); + int t2 = find(p[i].second); + if(t1 != t2) + { + ans[i-1] = ans[i] - 1; + F[t1] = t2; + } + else ans[i-1] = ans[i]; + } + for(int i = 1;i <= m;i++) + printf("%d\n",ans[i]); + } + return 0; +} diff --git a/HDOJ/4497_autoAC.cpp b/HDOJ/4497_autoAC.cpp new file mode 100644 index 0000000..0736118 --- /dev/null +++ b/HDOJ/4497_autoAC.cpp @@ -0,0 +1,72 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +const int INF = 0x3f3f3f3f; +const int dir[8][2] = {{-1,0},{1,0},{0,-1},{0,1},{-1,-1},{-1,1},{1,-1},{1,1}}; +using namespace std; +#define LL __int64 +const int MAX=100002; +int prime[MAX]; +bool flag[MAX]; +int main(void) +{ + int t; + scanf("%d", &t); + memset(flag, true, sizeof(flag)); + int cnt = 0; + for (int i = 2; i * i <= 100000; ++i) + { + if (flag[i]) + for (int j = i*2; j <= 100000; j+=i) + flag[j] = false; + } + for (int i = 2; i <= 100000; ++i) if(flag[i]) prime[cnt++] = i; + while (t--) + { + int G, L; + scanf("%d%d", &G, &L); + int ans = 1; + if (L % G) + { + printf("0\n"); + continue; + } + int K = L / G, S = K; + for (int i = 0; i < cnt; ++i) + { + if (prime[i] * prime[i] > S) break; + if (K%prime[i] == 0) + { + int touch = 0; + while (K%prime[i] == 0) + { + K /= prime[i]; touch++; + } + ans *= touch * 6; + } + } + if (K != 1) ans *= 6; + printf("%d\n", ans); + } + return 0; +} diff --git a/HDOJ/4498_autoAC.cpp b/HDOJ/4498_autoAC.cpp new file mode 100644 index 0000000..8341aff --- /dev/null +++ b/HDOJ/4498_autoAC.cpp @@ -0,0 +1,115 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +vectorx; +void add(int a1,int b1,int c1) +{ + if(a1 == 0 && b1 == 0) + { + return; + } + if(a1 == 0) + { + double t = -c1*1.0/b1; + if(t >= 0 && t <= 100) + x.push_back(t); + return; + } + long long deta = b1*b1 - 4LL*a1*c1; + if(deta < 0)return; + if(deta == 0) + { + double t = (-1.0 * b1)/(2.0 * a1); + if(t >= 0 && t <= 100) + x.push_back(t); + } + else + { + double t1 = (-1.0 * b1 + sqrt(1.0*deta))/(2.0*a1); + double t2 = (-1.0 * b1 - sqrt(1.0*deta))/(2.0*a1); + if(t1 >= 0 && t1 <= 100) + x.push_back(t1); + if(t2 >= 0 && t2 <= 100) + x.push_back(t2); + } +} +int A[100],B[100],C[100]; +int best; +double F(double x1) +{ + return sqrt(1.0 + (x1*2*A[best] + 1.0 * B[best])*(x1*2*A[best] + 1.0 * B[best])); +} +double simpson(double a,double b) +{ + double c = a + (b-a)/2; + return (F(a) + 4*F(c) + F(b))*(b-a)/6; +} +double asr(double a,double b,double eps,double A) +{ + double c = a + (b-a)/2; + double L = simpson(a,c); + double R = simpson(c,b); + if(fabs(L+R-A) <= 15*eps)return L+R+(L+R-A)/15; + return asr(a,c,eps/2,L) + asr(c,b,eps/2,R); +} +double asr(double a,double b,double eps) +{ + return asr(a,b,eps,simpson(a,b)); +} +int main() +{ + int T; + int k,a,b; + scanf("%d",&T); + while(T--) + { + int n; + scanf("%d",&n); + A[0] = 0; + B[0] = 0; + C[0] = 100; + for(int i = 1;i <= n;i++) + { + scanf("%d%d%d",&k,&a,&b); + A[i] = k; + B[i] = -2*a*k; + C[i] = k*a*a + b; + } + x.clear(); + for(int i = 0;i <= n;i++) + for(int j = i+1;j <= n;j++) + add(A[i]-A[j],B[i] - B[j],C[i] - C[j]); + double ans = 0; + x.push_back(0); + x.push_back(100); + sort(x.begin(),x.end()); + int sz = x.size(); + for(int i = 0;i < sz-1;i++) + { + double x1 = x[i]; + double x2 = x[i+1]; + if(fabs(x2-x1) < 1e-8)continue; + double mid = (x1 + x2)/2; + best = 0; + for(int j = 1;j <= n;j++) + { + double tmp1 = mid*mid*A[best] + mid*B[best] + C[best]; + double tmp2 = mid*mid*A[j] + mid*B[j] + C[j]; + if(tmp2 < tmp1)best = j; + } + ans += asr(x1,x2,1e-8); + } + printf("%.2lf\n",ans); + } + return 0; +} diff --git a/HDOJ/4499_autoAC.cpp b/HDOJ/4499_autoAC.cpp new file mode 100644 index 0000000..103696d --- /dev/null +++ b/HDOJ/4499_autoAC.cpp @@ -0,0 +1,74 @@ +#include +#include +#include +using namespace std; +const int MAX_N = 5 + 2; +int vis[MAX_N][MAX_N]; +int n, m, q, _max; +bool decide(int i, int j) +{ + int flag = 0; + if(vis[i][j] == 1) + return false; + for(int k = i - 1; k >= 0; k--) + { + if(vis[k][j] == 1) + flag++; + else if(vis[k][j] == 2) + { + if(flag == 1) + return false; + else + flag++; + } + } + flag = 0; + for(int k = j - 1; k >= 0; k--) + { + if(vis[i][k] == 1) + flag++; + else if(vis[i][k] == 2) + { + if(flag == 1) + return false; + else + flag++; + } + } + return true; +} +void dfs(int cnt, int x, int y) +{ + for(int i = x; i < n; i++) + { + for(int j = 0; j < m; j++) + { + if(x == i && j < y) + continue; + if(decide(i, j)) + { + vis[i][j] = 2; + dfs(cnt + 1, i, j + 1); + vis[i][j] = 0; + } + } + } + _max = max(_max, cnt); +} +int main() +{ + while(scanf("%d%d%d", &n, &m, &q) != EOF) + { + int a, b; + _max = 0; + memset(vis, 0, sizeof(vis)); + for(int i = 0; i < q; i++) + { + scanf("%d%d", &a, &b); + vis[a][b] = 1; + } + dfs(0, 0, 0); + cout << _max << endl; + } + return 0; +}